IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jan 8, 2010, 2:24:01 PM (17 years ago)
Author:
Paul Price
Message:

Dual convolution seems to be working again!

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionVisual.c

    r26505 r26547  
    242242
    243243    for (int i = 0; i < kernels->num; i++) {
    244         pmSubtractionKernelPreCalc *preCalc = kernels->preCalc->data[i];
    245         psKernel *kernel = preCalc->kernel;
    246 
    247         int xSub = i % NXsub;
    248         int ySub = i / NXsub;
    249 
    250         int xPix = xSub * (2*footprint + 1 + 3) + footprint;
    251         int yPix = ySub * (2*footprint + 1 + 3) + footprint;
    252 
    253         double sum = 0.0;
    254         for (int y = -footprint; y <= footprint; y++) {
    255             for (int x = -footprint; x <= footprint; x++) {
    256                 output->data.F32[y + yPix][x + xPix] = kernel->kernel[y][x];
    257                 sum += kernel->kernel[y][x];
    258             }
    259         }
    260         fprintf (stderr, "kernel %d, sum %f\n", i, sum);
    261     }                                                   
    262        
     244        pmSubtractionKernelPreCalc *preCalc = kernels->preCalc->data[i];
     245        psKernel *kernel = preCalc->kernel;
     246
     247        int xSub = i % NXsub;
     248        int ySub = i / NXsub;
     249
     250        int xPix = xSub * (2*footprint + 1 + 3) + footprint;
     251        int yPix = ySub * (2*footprint + 1 + 3) + footprint;
     252
     253        double sum = 0.0;
     254        for (int y = -footprint; y <= footprint; y++) {
     255            for (int x = -footprint; x <= footprint; x++) {
     256                output->data.F32[y + yPix][x + xPix] = kernel->kernel[y][x];
     257                sum += kernel->kernel[y][x];
     258            }
     259        }
     260        fprintf (stderr, "kernel %d, sum %f\n", i, sum);
     261    }
     262
    263263    pmVisualScaleImage(kapa1, output, "Image", 0, true);
    264264    pmVisualAskUser(&plotImage);
     
    280280    float maxFlux = NAN;
    281281    for (int i = 0; i < stamps->num; i++) {
    282         pmSubtractionStamp *stamp = stamps->stamps->data[i];
    283         if (!isfinite(stamp->flux)) continue;
    284         if (!stamp->convolutions1 && !stamp->convolutions2) continue;
    285         if (!maxStamp) {
    286             maxFlux = stamp->flux;
    287             maxStamp = stamp;
    288             continue;
    289         }
    290         if (stamp->flux > maxFlux) {
    291             maxFlux = stamp->flux;
    292             maxStamp = stamp;
    293         }
     282        pmSubtractionStamp *stamp = stamps->stamps->data[i];
     283        if (!isfinite(stamp->flux)) continue;
     284        if (!stamp->convolutions1 && !stamp->convolutions2) continue;
     285        if (!maxStamp) {
     286            maxFlux = stamp->flux;
     287            maxStamp = stamp;
     288            continue;
     289        }
     290        if (stamp->flux > maxFlux) {
     291            maxFlux = stamp->flux;
     292            maxStamp = stamp;
     293        }
    294294    }
    295295
    296296    if (!isfinite(maxStamp->flux)) {
    297         fprintf (stderr, "no valid stamps?\n");
     297        fprintf (stderr, "no valid stamps?\n");
    298298    }
    299299
     
    301301
    302302    if (maxStamp->convolutions1) {
    303         // output image is a grid of NXsub by NYsub sub-images
    304         nKernels = maxStamp->convolutions1->n;
    305         int NXsub = sqrt(nKernels);
    306         int NYsub = nKernels / NXsub;
    307         if (nKernels % NXsub) NYsub++;
    308 
    309         int NXpix = NXsub * (2*footprint + 1 + 3);
    310         int NYpix = NYsub * (2*footprint + 1 + 3);
    311 
    312         psImage *output = psImageAlloc(NXpix, NYpix, PS_TYPE_F32);
    313         psImageInit (output, 0.0);
    314 
    315         for (int i = 0; i < nKernels; i++) {
     303        // output image is a grid of NXsub by NYsub sub-images
     304        nKernels = maxStamp->convolutions1->n;
     305        int NXsub = sqrt(nKernels);
     306        int NYsub = nKernels / NXsub;
     307        if (nKernels % NXsub) NYsub++;
     308
     309        int NXpix = NXsub * (2*footprint + 1 + 3);
     310        int NYpix = NYsub * (2*footprint + 1 + 3);
     311
     312        psImage *output = psImageAlloc(NXpix, NYpix, PS_TYPE_F32);
     313        psImageInit (output, 0.0);
     314
     315        for (int i = 0; i < nKernels; i++) {
    316316            psKernel *kernel = maxStamp->convolutions1->data[i];
    317            
    318             int xSub = i % NXsub;
    319             int ySub = i / NXsub;
    320            
    321             int xPix = xSub * (2*footprint + 1 + 3) + footprint;
    322             int yPix = ySub * (2*footprint + 1 + 3) + footprint;
    323            
    324             double sum = 0.0;
    325             for (int y = -footprint; y <= footprint; y++) {
    326                 for (int x = -footprint; x <= footprint; x++) {
    327                     output->data.F32[y + yPix][x + xPix] = kernel->kernel[y][x];
    328                     sum += kernel->kernel[y][x];
    329                 }
    330             }
    331             fprintf (stderr, "kernel %d, sum %f\n", i, sum);
    332         }               
    333         pmVisualScaleImage(kapa2, output, "Image", 0, true);
    334     }                                   
    335        
     317
     318            int xSub = i % NXsub;
     319            int ySub = i / NXsub;
     320
     321            int xPix = xSub * (2*footprint + 1 + 3) + footprint;
     322            int yPix = ySub * (2*footprint + 1 + 3) + footprint;
     323
     324            double sum = 0.0;
     325            for (int y = -footprint; y <= footprint; y++) {
     326                for (int x = -footprint; x <= footprint; x++) {
     327                    output->data.F32[y + yPix][x + xPix] = kernel->kernel[y][x];
     328                    sum += kernel->kernel[y][x];
     329                }
     330            }
     331            fprintf (stderr, "kernel %d, sum %f\n", i, sum);
     332        }
     333        pmVisualScaleImage(kapa2, output, "Image", 0, true);
     334    }
     335
    336336    if (maxStamp->convolutions2) {
    337         // output image is a grid of NXsub by NYsub sub-images
    338         nKernels = maxStamp->convolutions2->n;
    339         int NXsub = sqrt(nKernels);
    340         int NYsub = nKernels / NXsub;
    341         if (nKernels % NXsub) NYsub++;
    342 
    343         int NXpix = NXsub * (2*footprint + 1 + 3);
    344         int NYpix = NYsub * (2*footprint + 1 + 3);
    345 
    346         psImage *output = psImageAlloc(NXpix, NYpix, PS_TYPE_F32);
    347         psImageInit (output, 0.0);
    348 
    349         for (int i = 0; i < nKernels; i++) {
     337        // output image is a grid of NXsub by NYsub sub-images
     338        nKernels = maxStamp->convolutions2->n;
     339        int NXsub = sqrt(nKernels);
     340        int NYsub = nKernels / NXsub;
     341        if (nKernels % NXsub) NYsub++;
     342
     343        int NXpix = NXsub * (2*footprint + 1 + 3);
     344        int NYpix = NYsub * (2*footprint + 1 + 3);
     345
     346        psImage *output = psImageAlloc(NXpix, NYpix, PS_TYPE_F32);
     347        psImageInit (output, 0.0);
     348
     349        for (int i = 0; i < nKernels; i++) {
    350350            psKernel *kernel = maxStamp->convolutions2->data[i];
    351            
    352             int xSub = i % NXsub;
    353             int ySub = i / NXsub;
    354            
    355             int xPix = xSub * (2*footprint + 1 + 3) + footprint;
    356             int yPix = ySub * (2*footprint + 1 + 3) + footprint;
    357            
    358             double sum = 0.0;
    359             for (int y = -footprint; y <= footprint; y++) {
    360                 for (int x = -footprint; x <= footprint; x++) {
    361                     output->data.F32[y + yPix][x + xPix] = kernel->kernel[y][x];
    362                     sum += kernel->kernel[y][x];
    363                 }
    364             }
    365             fprintf (stderr, "kernel %d, sum %f\n", i, sum);
    366         }               
    367         pmVisualScaleImage(kapa2, output, "Image", 1, true);
    368     }                                   
    369        
     351
     352            int xSub = i % NXsub;
     353            int ySub = i / NXsub;
     354
     355            int xPix = xSub * (2*footprint + 1 + 3) + footprint;
     356            int yPix = ySub * (2*footprint + 1 + 3) + footprint;
     357
     358            double sum = 0.0;
     359            for (int y = -footprint; y <= footprint; y++) {
     360                for (int x = -footprint; x <= footprint; x++) {
     361                    output->data.F32[y + yPix][x + xPix] = kernel->kernel[y][x];
     362                    sum += kernel->kernel[y][x];
     363                }
     364            }
     365            fprintf (stderr, "kernel %d, sum %f\n", i, sum);
     366        }
     367        pmVisualScaleImage(kapa2, output, "Image", 1, true);
     368    }
     369
    370370    pmVisualAskUser(&plotImage);
    371371    return true;
     
    394394
    395395        overlay[Noverlay].type = KII_OVERLAY_BOX;
    396         if ((stamp->x < 1.0) && (stamp->y < 1.0)) {
    397             // fprintf (stderr, "stamp zero: %f %f\n", stamp->x, stamp->y);
    398             continue;
    399         }
    400         if (!isfinite(stamp->x) && !isfinite(stamp->y)) {
    401             // fprintf (stderr, "stamp nan: %f %f\n", stamp->x, stamp->y);
    402             continue;
    403         }
     396        if ((stamp->x < 1.0) && (stamp->y < 1.0)) {
     397            // fprintf (stderr, "stamp zero: %f %f\n", stamp->x, stamp->y);
     398            continue;
     399        }
     400        if (!isfinite(stamp->x) && !isfinite(stamp->y)) {
     401            // fprintf (stderr, "stamp nan: %f %f\n", stamp->x, stamp->y);
     402            continue;
     403        }
    404404        overlay[Noverlay].x = stamp->x;
    405405        overlay[Noverlay].y = stamp->y;
     
    437437    float NXf = sqrt(stamps->num);
    438438    NX = (int) NXf == NXf ? NXf : NXf + 1.0;
    439    
     439
    440440    float NYf = stamps->num / NX;
    441441    NY = (int) NYf == NY ? NYf : NYf + 1.0;
     
    453453    differenceImage  = psImageAlloc (NXpix, NYpix, PS_TYPE_F32);
    454454    convolutionImage = psImageAlloc (NXpix, NYpix, PS_TYPE_F32);
    455    
     455
    456456    psImageInit (sourceImage,      0.0);
    457457    psImageInit (targetImage,      0.0);
     
    479479    sum = 0.0;
    480480    for (int y = -footprint; y <= footprint; y++) {
    481         for (int x = -footprint; x <= footprint; x++) {
    482             targetImage->data.F32[y + NYpix][x + NXpix] = target->kernel[y][x];
    483             sum += targetImage->data.F32[y + NYpix][x + NXpix];
    484         }
     481        for (int x = -footprint; x <= footprint; x++) {
     482            targetImage->data.F32[y + NYpix][x + NXpix] = target->kernel[y][x];
     483            sum += targetImage->data.F32[y + NYpix][x + NXpix];
     484        }
    485485    }
    486486    targetImage->data.F32[footprint + 1 + NYpix][NXpix] = sum;
     
    489489    sum = 0.0;
    490490    for (int y = -footprint; y <= footprint; y++) {
    491         for (int x = -footprint; x <= footprint; x++) {
    492             sourceImage->data.F32[y + NYpix][x + NXpix] = source->kernel[y][x];
    493             sum += sourceImage->data.F32[y + NYpix][x + NXpix];
    494         }
     491        for (int x = -footprint; x <= footprint; x++) {
     492            sourceImage->data.F32[y + NYpix][x + NXpix] = source->kernel[y][x];
     493            sum += sourceImage->data.F32[y + NYpix][x + NXpix];
     494        }
    495495    }
    496496    sourceImage->data.F32[footprint + 1 + NYpix][NXpix] = sum;
     
    499499    sum = 0.0;
    500500    for (int y = -footprint; y <= footprint; y++) {
    501         for (int x = -footprint; x <= footprint; x++) {
    502             convolutionImage->data.F32[y + NYpix][x + NXpix] = -convolution->kernel[y][x];
    503             sum += convolutionImage->data.F32[y + NYpix][x + NXpix];
    504         }
     501        for (int x = -footprint; x <= footprint; x++) {
     502            convolutionImage->data.F32[y + NYpix][x + NXpix] = -convolution->kernel[y][x];
     503            sum += convolutionImage->data.F32[y + NYpix][x + NXpix];
     504        }
    505505    }
    506506    convolutionImage->data.F32[footprint + 1 + NYpix][NXpix] = sum;
    507    
     507
    508508    // insert the (difference) kernel into the (difference) image:
    509509    sum = 0.0;
    510510    for (int y = -footprint; y <= footprint; y++) {
    511         for (int x = -footprint; x <= footprint; x++) {
    512             differenceImage->data.F32[y + NYpix][x + NXpix] = target->kernel[y][x] - background - source->kernel[y][x] * norm;
    513             sum += differenceImage->data.F32[y + NYpix][x + NXpix];
    514         }
     511        for (int x = -footprint; x <= footprint; x++) {
     512            differenceImage->data.F32[y + NYpix][x + NXpix] = target->kernel[y][x] - background - source->kernel[y][x] * norm;
     513            sum += differenceImage->data.F32[y + NYpix][x + NXpix];
     514        }
    515515    }
    516516    differenceImage->data.F32[footprint + 1 + NYpix][NXpix] = sum;
     
    519519    sum = 0.0;
    520520    for (int y = -footprint; y <= footprint; y++) {
    521         for (int x = -footprint; x <= footprint; x++) {
    522             residualImage->data.F32[y + NYpix][x + NXpix] = target->kernel[y][x] - background - source->kernel[y][x] * norm + convolution->kernel[y][x];
    523             sum += residualImage->data.F32[y + NYpix][x + NXpix];
    524         }
     521        for (int x = -footprint; x <= footprint; x++) {
     522            residualImage->data.F32[y + NYpix][x + NXpix] = target->kernel[y][x] - background - source->kernel[y][x] * norm + convolution->kernel[y][x];
     523            sum += residualImage->data.F32[y + NYpix][x + NXpix];
     524        }
    525525    }
    526526    residualImage->data.F32[footprint + 1 + NYpix][NXpix] = sum;
     
    528528    // insert the (fresidual) kernel into the (fresidual) image:
    529529    for (int y = -footprint; y <= footprint; y++) {
    530         for (int x = -footprint; x <= footprint; x++) {
    531             fresidualImage->data.F32[y + NYpix][x + NXpix] = residualImage->data.F32[y + NYpix][x + NXpix] / sqrt(PS_MAX(target->kernel[y][x], 100.0));
    532         }
     530        for (int x = -footprint; x <= footprint; x++) {
     531            fresidualImage->data.F32[y + NYpix][x + NXpix] = residualImage->data.F32[y + NYpix][x + NXpix] / sqrt(PS_MAX(target->kernel[y][x], 100.0));
     532        }
    533533    }
    534534    return true;
     
    536536
    537537bool pmSubtractionVisualShowFit(double norm) {
     538
     539    if (!pmVisualIsVisual()) return true;
    538540
    539541    // XXX a dumb test : dump the residual image and exit
    540542    {
    541         psMetadata *header = psMetadataAlloc();
     543        psMetadata *header = psMetadataAlloc();
    542544        psMetadataAddF32 (header, PS_LIST_TAIL, "NORM", 0, "Normalization", norm);
    543         psFits *fits = psFitsOpen("resid.fits", "w");
    544         psFitsWriteImage(fits, header, residualImage, 0, NULL);
    545         psFitsClose(fits);
    546         exit (0);
    547     }
    548 
    549     // if (!pmVisualIsVisual()) return true;
     545        psFits *fits = psFitsOpen("resid.fits", "w");
     546        psFitsWriteImage(fits, header, residualImage, 0, NULL);
     547        psFitsClose(fits);
     548        exit (0);
     549    }
     550
    550551    if (!pmVisualInitWindow(&kapa1, "ppSub:Images")) return false;
    551552    if (!pmVisualInitWindow(&kapa2, "ppSub:Misc")) return false;
     
    606607    for (int i = 0; i < kernels->num; i++) {
    607608        x->data.F32[i] = i;
    608         y->data.F32[i] = p_pmSubtractionSolutionCoeff(kernels, polyValues, i, false);
     609        y->data.F32[i] = p_pmSubtractionSolutionCoeff(kernels, polyValues, i, false);
    609610        graphdata.ymin = PS_MIN(graphdata.ymin, y->data.F32[i]);
    610611        graphdata.ymax = PS_MAX(graphdata.ymax, y->data.F32[i]);
Note: See TracChangeset for help on using the changeset viewer.