void CWndDisplayTexture::OnLButtonDown(UINT nFlags, CPoint point) 
{
  // start drawing line
  m_bDrawLine = TRUE;
  // store mouse start coordinates
  m_pixLineStartU = point.x;
  m_pixLineStartV = point.y;
  m_pixLineStopU  = point.x;
  m_pixLineStopV  = point.y;

  // get texture data from surface
  CTextureData *pTD = (CTextureData*)m_toTexture.GetData();
  PIX pixU = point.x-m_pixWinOffsetU;
  PIX pixV = point.y-m_pixWinOffsetV;
  if( pixU<0 || pixU>m_pixWinWidth ) return;
  if( pixV<0 || pixV>m_pixWinHeight) return;
  pixU = PIX(pixU/m_fWndTexRatio);
  pixV = PIX(pixV/m_fWndTexRatio);
  
  // if there is valid mouse down function set
  if( m_pLeftMouseButtonClicked != NULL)
  { // call it
    m_pLeftMouseButtonClicked(pixU, pixV);
  }

	CWnd::OnLButtonDown(nFlags, point);
}
void CWndDisplayTexture::OnMouseMove(UINT nFlags, CPoint point) 
{
  // if right mouse is down
  if (nFlags&MK_RBUTTON) {
    // get texture data from surface
    CTextureData *pTD = (CTextureData*)m_toTexture.GetData();
    PIX pixU = point.x-m_pixWinOffsetU;
    PIX pixV = point.y-m_pixWinOffsetV;
    if( pixU<0 || pixU>m_pixWinWidth ) return;
    if( pixV<0 || pixV>m_pixWinHeight) return;
    pixU = PIX(pixU/m_fWndTexRatio);
    pixV = PIX(pixV/m_fWndTexRatio);
  
    // if there is valid mouse down function set
    if( m_pRightMouseButtonMoved != NULL)
    { // call it
      m_pRightMouseButtonMoved(pixU, pixV);
    }
  // if left mouse is down
  } else if (nFlags&MK_LBUTTON) {
    // store mouse coordinates
    m_pixLineStopU = point.x;
    m_pixLineStopV = point.y;
  }
	
	CWnd::OnMouseMove(nFlags, point);
}
IplImage* findedge(IplImage* img,int thresh)
{
	int i,j,ht,wd;
	ht=img->height;
	wd=img->width;

	IplImage* res;
	res=cvCreateImage(cvSize(img->width,img->height),IPL_DEPTH_8U,1);

	for(i=0;i<ht;i++)
		for(j=0;j<wd;j++)
			PIX(res,i,j,0)=(uchar)(.33*PIX(img,i,j,0)+.56*PIX(img,i,j,1)+.11*PIX(img,i,j,2));

	for(i=1;i<ht-1;i++)
		for(j=1;j<wd-1;j++)
			PIX(res,i,j,0)=(pixelcheck(img,thresh,i,j))?0:255;
	return res;
}
Пример #4
0
void treasure::set_direct_frame(short whatframe)
{
	unsigned char  * data;
	frame = whatframe;

	data = screenp->myloader->graphics[PIX(order, family)];
	bmp = (data+3 + frame*size);

}
Пример #5
0
static INDEX SliderPixToIndex(PIX pixOffset, INDEX iVisible, INDEX iTotal, PIXaabbox2D boxFull)
{
  FLOAT fSize = ClampUp(FLOAT(iVisible)/iTotal, 1.0f);
  PIX pixFull = boxFull.Size()(2);
  PIX pixSize = PIX(pixFull*fSize);
  if (pixSize>=boxFull.Size()(2)) {
    return 0;
  }
  return (iTotal*pixOffset)/pixFull;
}
void CWndDisplayTexture::OnRButtonDown(UINT nFlags, CPoint point) 
{
  // get texture data from surface
  CTextureData *pTD = (CTextureData*)m_toTexture.GetData();
  PIX pixU = point.x-m_pixWinOffsetU;
  PIX pixV = point.y-m_pixWinOffsetV;
  if( pixU<0 || pixU>m_pixWinWidth ) return;
  if( pixV<0 || pixV>m_pixWinHeight) return;
  pixU = PIX(pixU/m_fWndTexRatio);
  pixV = PIX(pixV/m_fWndTexRatio);
  
  // if there is valid mouse down function set
  if( m_pRightMouseButtonClicked != NULL)
  { // call it
    m_pRightMouseButtonClicked(pixU, pixV);
  }

	CWnd::OnRButtonDown(nFlags, point);
}
Пример #7
0
/** interpolateBiLin: bi-linear interpolation function, see interpolate */
void _FLT(interpolateBiLin)(unsigned char *rv, float x, float y,
                            unsigned char* img, int width, int height,
                            unsigned char def)
{
    if (x < 0 || x > width - 1 || y < 0 || y > height - 1) {
        _FLT(interpolateBiLinBorder)(rv, x, y, img, width, height, def);
    } else {
        int x_f = myfloor(x);
        int x_c = x_f+1;
        int y_f = myfloor(y);
        int y_c = y_f+1;
        short v1 = PIX(img, x_c, y_c, width, height);
        short v2 = PIX(img, x_c, y_f, width, height);
        short v3 = PIX(img, x_f, y_c, width, height);
        short v4 = PIX(img, x_f, y_f, width, height);
        float s  = (v1*(x - x_f)+v3*(x_c - x))*(y - y_f) +
                   (v2*(x - x_f) + v4*(x_c - x))*(y_c - y);
        *rv = (unsigned char)s;
    }
}
Пример #8
0
static PIXaabbox2D GetSliderBox(INDEX iFirst, INDEX iVisible, INDEX iTotal,
  PIXaabbox2D boxFull)
{
  FLOAT fSize = ClampUp(FLOAT(iVisible)/iTotal, 1.0f);
  PIX pixFull = boxFull.Size()(2);
  PIX pixSize = PIX(pixFull*fSize);
  pixSize = ClampDn(pixSize, boxFull.Size()(1));
  PIX pixTop = pixFull*(FLOAT(iFirst)/iTotal)+boxFull.Min()(2);
  PIX pixI0 = boxFull.Min()(1);
  PIX pixI1 = boxFull.Max()(1);
  return PIXaabbox2D(PIX2D(pixI0, pixTop), PIX2D(pixI1, pixTop+pixSize));
}
void CWndDisplayTexture::OnLButtonUp(UINT nFlags, CPoint point) 
{
  // stop drawing line
  m_bDrawLine = FALSE;

  // get texture data from surface
  CTextureData *pTD = (CTextureData*)m_toTexture.GetData();
  PIX pixU = point.x-m_pixWinOffsetU;
  PIX pixV = point.y-m_pixWinOffsetV;
  if( pixU<0 || pixU>m_pixWinWidth ) return;
  if( pixV<0 || pixV>m_pixWinHeight) return;
  pixU = PIX(pixU/m_fWndTexRatio);
  pixV = PIX(pixV/m_fWndTexRatio);
  
  // if there is valid mouse down function set
  if( m_pLeftMouseButtonReleased != NULL)
  { // call it
    m_pLeftMouseButtonReleased(pixU, pixV);
  }

	CWnd::OnLButtonUp(nFlags, point);
}
int pixelcheck(IplImage* img,int thresh,int x,int y)
{
	int i,j,max,min;
	min=256;
	max=-1;
	for(i=x-1;i<=x+1;i++)
	{	
		if(i<0 || i>=img->height)
			continue;
		for(j=y-1;j<=y+1;j++)
		{   
			if(j<0 || j>=img->width)
				continue;
			if(PIX(img,i,j,0)<min)
				min=PIX(img,i,j,0);
			if(PIX(img,i,j,0)>max)
				max=PIX(img,i,j,0);
		}
	}
	if((max-min)>thresh)
		return 1;
	return 0;
}
void clearnoise(IplImage *frame, int action, int kernel){
	int i, j, black, white, i2, j2, k;
	int ht = frame->height;
	int wd = frame->width;
	for(i = 0; i< ht; i++){
		for(j = 0; j< wd; j++){
			i2 = i-2;
			j2 = j-2;
			for(k=1; k<9; k++){
				if(i2<0 || i2>=ht || j2<0 || j2>=wd)
					continue;
				if(PIX(frame,i2+(k/3),j2+(k%3),0)==0)
					black++;
				else white++;
				if(!action)
					if(white>black)
						PIX(frame,i2+(k/3),j2+(k%3),0)=255;
				else
					if(black>white)
						PIX(frame,i2+(k/3),j2+(k%3),0)=0;
			}
		}
	}
}
void CDlgCreateSpecularTexture::DrawGraph( CDrawPort *pdp, FLOAT fExp)
{
  pdp->Fill(C_WHITE|CT_OPAQUE);
  PIX pixSizeI = pdp->GetWidth();
  PIX pixSizeJ = pdp->GetHeight();
  PIX pixLastI = 0;
  PIX pixLastJ = 0;
  for (PIX pixI=0; pixI<pixSizeI; pixI++) {
    FLOAT fAlpha = 90.0f*pixI/pixSizeI;
    FLOAT fCos = FLOAT(pow(Cos(fAlpha), fExp));
    PIX pixJ = PIX(pixSizeJ*(1-fCos));
    pdp->DrawLine(pixLastI, pixLastJ, pixI, pixJ, C_BLACK|CT_OPAQUE);
    pixLastI = pixI;
    pixLastJ = pixJ;
  }
}
IplImage* detectthis(IplImage *img, int b,int g,int r,int b1, int g1, int r1)
{
	int i,j,ht,wd,flag;
	ht=img->height;
	wd=img->width;

	IplImage* grey=cvCreateImage(cvSize(wd,ht),IPL_DEPTH_8U,1);

	for(i=0;i<ht;i++){
		for(j=0;j<wd;j++){
			flag=0;
			if(PIX(img,i,j,0)>b-b1&&PIX(img,i,j,0)<b+b1)
				if(PIX(img,i,j,1)>g-g1&&PIX(img,i,j,1)<g+g1)
					if(PIX(img,i,j,2)>r-r1&&PIX(img,i,j,2)<r+r1)
						flag=1;
			PIX(grey,i,j,0)=(flag)?255:0;
		}
	}
	return grey;
}
Пример #14
0
/* acsrej_init -- get the initial average pixel values

  Description:
  ------------
  Get the initial average according to the specified scheme

  Date          Author          Description
  ----          ------          -----------
  22-Sep-1998   W.J. Hack       initial version, uses multiamp noise,gain
  20-Mar-2000   W.J. Hack       corrected problem with rog2, needed to be array
  15-Apr-2002   W.J. Hack       correctly zero'd out npts array, added
                                DQ checking for BOTH median and minimum images,
                                also added ERR array for median image.
  26-Aug-2002   J. Blakeslee    Modified threshhold for minimum to use SCALENSE
                                only with sky-subtracted pixels.
  01-Dec-2015   P.L. Lim        Calculations now entirely in electrons.
  13-Jan-2016   P.L. Lim        Removed variance init and cleaned up function.
*/
int acsrej_init (IODescPtr ipsci[], IODescPtr ipdq[], clpar *par, int nimgs,
                 int dim_x, int dim_y, float efac[], float skyval[],
                 SingleGroup *sg, float *work) {
    /*
      Parameters:

      ipsci   i: Array of pointers to SCI extension of the given EXTVER,
                 each pointer is an input image. Unit now in electrons.
      ipdq    i: Array of pointers to DQ extension of the given EXTVER,
                 each pointer is an input image.
      par     i: User specified parameters.
      nimgs   i: Number of input images.
      dim_x, dim_y  i: Image dimension taken from the first input image.
                       All images must have the same dimension.
      efac    i: Array of EXPTIME for each image. If all inputs have
                 EXPTIME=0 (all biases), then the values are all set to 1.
      skyval  i: Array of sky values for each input image.
                 Unit now in electrons.
      sg      o: Its "sci" component is the average image used for
                 comparison during CR rejection. Unit is e/s.
                 This is really the median or minimum depending on
                 "initgues" provided by the user.
      work    o: Intermediate result used to calculate sg but not used
                 outside this function.
    */
    extern int status;

    float     val, raw, dumf;
    int       i, j, n, p, dum;
    float     *buf;
    short     *bufdq;
    int       *npts, *ipts;
    short     dqpat;
    Hdr       dqhdr;

    void      ipiksrt (float [], int, int[]);

    /* -------------------------------- begin ------------------------------- */

    dqpat = par->badinpdq;

    ipts = calloc (nimgs, sizeof(int));
    npts = calloc (dim_x, sizeof(int));
    buf = calloc (dim_x, sizeof(float));
    bufdq = calloc (dim_x, sizeof(short));

    /* Use the stack median to construct the initial average. */
    if (strncmp(par->initgues, "median", 3) == 0) {
        for (j = 0; j < dim_y; j++) {
            memset (npts, 0, dim_x*sizeof(int));

            for (n = 0; n < nimgs; n++) {
                initHdr(&dqhdr);
                getHeader(ipdq[n], &dqhdr);
                getFloatLine (ipsci[n], j, buf);  /* electrons */
                getShortLine (ipdq[n], j, bufdq);
                freeHdr(&dqhdr);

                /* Only use GOOD pixels to build initial image.
                   work array is already initialized to zeroes in acsrej_do.c */
                if (efac[n] > 0.) {
                    for (i = 0; i < dim_x; i++) {
                        if ((bufdq[i] & dqpat) == OK) {
                            PIX(work, npts[i], i, nimgs) =
                                (buf[i] - skyval[n]) / efac[n];  /* e/s */
                            npts[i] += 1;
                        }
                    }
                }
            }  /* End of nimgs loop */

            /* ALL AMPS */
            for (i = 0; i < dim_x; i++) {
                dum = npts[i];  /* Number of good data points */
                if (dum == 0)
                    Pix(sg->sci.data, i, j) = 0.0F;
                else {
                    /* Setup index array for sorting... */
                    for (p=0; p < nimgs; p++) ipts[p] = p;
                    /* Sort pixel stack and corresponding index array. */
                    ipiksrt (&PIX(work, 0, i, nimgs), dum, ipts);
                     /* Even number of input images for this pixel */
                    if ((dum / 2) * 2 == dum) {
                        Pix(sg->sci.data, i, j) =
                            (PIX(work, dum / 2 - 1, i, nimgs) +
                             PIX(work, dum / 2, i, nimgs)) / 2.;
                    } else {
                        Pix(sg->sci.data, i, j) = PIX(work, dum / 2, i, nimgs);
                    }
                }
            } /* End loop over ALL AMPS used on pixels in the line */
        } /* End loop over lines */

    /* use the minimum to construct the initial average */
    } else {
        if (strncmp(par->initgues, "minimum", 3) != 0) {
            sprintf (MsgText,
                     "Invalid INITGUES value %s, reset it to 'minimum'",
                     par->initgues);
            trlwarn (MsgText);
            strcpy (par->initgues, "minimum");
        }

        for (n = 0; n < nimgs; n++) {
            initHdr(&dqhdr);
            getHeader(ipdq[n], &dqhdr);

            for (j = 0; j < dim_y; j++) {
                getFloatLine (ipsci[n], j, buf);  /* electrons */
                getShortLine (ipdq[n], j, bufdq);

                /* ALL AMPS */
                for (i = 0; i < dim_x; i++) {
                    raw = buf[i];  /* e */
                    dumf = raw - skyval[n];  /* e */

                    if (efac[n] > 0.) {
                        /* Can be negative */
                        val = dumf / efac[n];  /* e/s */
                    } else {
                        val = 0.;
                    }

                    if ( (n == 0) || (val < Pix(sg->sci.data, i, j)) ) {
                        /* If this pixel is bad in the first image,
                           then the min is automatically set to 0. As a
                           result, only negative val is going to be stored and
                           valid positive min is ignored.
                           SLIGHTLY BUGGY HERE??? */
                        if ((bufdq[i] & dqpat) == OK && (efac[n] > 0.)) {
                            Pix(sg->sci.data, i, j) = val;  /* e/s */
                        } else {
                            Pix(sg->sci.data, i, j) = 0.;
                        }
                    }
                } /* End of loop over ALL AMPS for this line in each image */
            } /* End of loop over lines in image (y) */

            freeHdr(&dqhdr);
        } /* End of loop over images in set */
    }

    /* free the memory */
    free (ipts);
    free (npts);
    free (buf);
    free (bufdq);

    return (status);
}
Пример #15
0
int rej_init (IODescPtr ipsci[], IODescPtr ipdq[], clpar *par, int nimgs,
	      int dim_x, int dim_y, multiamp noise, multiamp gain, float efac[],
	      float skyval[], DataUnits bunit[], SingleGroup *sg, float *work) {

    extern int status;

    float  scale, val, raw, raw0, signal0;
    float  *buf;
    short  *bufdq;
    float  *exp2;
    int    i, j, n;
    int    dum;
    int    *npts, *ipts;
    float  noise2[NAMPS], rog2[NAMPS];
    float  gain2[NAMPS];
    float  nse[2], gn[2];
    int    ampx, ampy, detector, chip;
    int    k, p;
    short  dqpat;
    float  exp2n, expn;
    int    non_zero;
    Hdr    dqhdr;

    void ipiksrt (float [], int, int[]);
    void get_nsegn (int, int, int, int, float *, float*, float *, float *);

    /* -------------------------------- begin ------------------------------ */
    expn=0.0f;
    scale = par->scalense / 100.;
    ampx = gain.colx;
    ampy = gain.coly;
    detector = gain.detector;
    chip = gain.chip;
    dqpat = par->badinpdq;

    ipts = calloc (nimgs, sizeof(int));
    npts = calloc (dim_x, sizeof(int));
    buf = calloc (dim_x, sizeof(float));
    exp2 = (float *) calloc (nimgs, sizeof(float));
    bufdq = calloc (dim_x, sizeof(short));

    for (k = 0; k < NAMPS; k++) {
        gain2[k] = 0.;
        noise2[k] = 0.;
        /* Assumption: ALL images have the same noise/gain values */
        rog2[k] = SQ(noise.val[k]);
    }

    non_zero = 0;
    for (n = 0; n < nimgs; n++) {
        exp2[n] = SQ(efac[n]);
	if (efac[n] > 0.) non_zero++;
    }
    get_nsegn (detector, chip, ampx, ampy, gain.val, rog2, gain2, noise2); 

    /* Use the stack median to construct the initial average */
    if (strncmp(par->initgues, "median", 3) == 0) {
        for (j = 0; j < dim_y; j++) {
            memset (npts, 0, dim_x*sizeof(int));

            /* Set up the gain and noise values used for this line
	    ** in ALL images */
            if (j < ampy ) {
                gn[0] = gain2[AMP_C];
                gn[1] = gain2[AMP_D];
                nse[0] = noise2[AMP_C];
                nse[1] = noise2[AMP_D];
            } else {
                gn[0] = gain2[AMP_A];
                gn[1] = gain2[AMP_B];
                nse[0] = noise2[AMP_A];
                nse[1] = noise2[AMP_B];            
            }

            for (n = 0; n < nimgs; n++) {
                initHdr(&dqhdr);
                getHeader(ipdq[n],&dqhdr);
                getFloatLine (ipsci[n], j, buf);
                getShortLine (ipdq[n], j, bufdq);
                freeHdr(&dqhdr);

		/* Rescale SCI data, if necessary */
		if (bunit[n] == COUNTRATE) {
		    for (i = 0; i < dim_x; i++) {
			 buf[i] *= efac[n];
		    }
		}

                for (i = 0; i < dim_x; i++) {
		     if (efac[n] > 0.) {
                         /* Only use GOOD pixels to build initial image */
                         if ((bufdq[i] & dqpat) == OK) {
                             PIX(work,npts[i],i,nimgs) =
						(buf[i] - skyval[n]) / efac[n];
                             npts[i] += 1;
                         }
		     } else {
			 PIX(work,npts[i],i,nimgs) = 0.;
		     }
                }
            }
 
            for (i = 0; i < ampx; i++) {
                dum = npts[i];

                if (dum == 0)
                    Pix(sg->sci.data,i,j) = 0.0F;

                else {

		    /* Setup index array for sorting... */
		    for (p=0; p < nimgs; p++) ipts[p] = p;
		    /* Sort pixel stack and corresponding index array. */
                    ipiksrt (&PIX(work,0,i,nimgs), dum, ipts);

		    /* Use sorted index array to match proper exptimes to
		       selected pixels for use in ERR array calculation. */
                    if ((dum/2)*2 == dum) {
                        /* Even number of input images for this pixel */
                        Pix(sg->sci.data,i,j) = (PIX(work,dum/2-1,i,nimgs) +
						 PIX(work,dum/2,i,nimgs)) / 2.;
			expn = (exp2[ipts[dum/2-1]] + exp2[ipts[dum/2]]) / 2.;
                    } else {
			/* Odd number of input images for this pixel */
                        Pix(sg->sci.data,i,j) = PIX(work,dum/2,i,nimgs);
			expn = exp2[ipts[dum/2]];
		    }
                }
                
                raw0 = Pix(sg->sci.data,i,j);
		exp2n = (expn > 0.) ? expn : 1.;
                Pix(sg->err.data,i,j) = (nse[0]+ raw0/gn[0] + SQ(scale*raw0)) /
					exp2n;
            } /* End loop over FIRST AMP used on pixels in the line */
             
            for (i = ampx; i < dim_x; i++) {
                dum = npts[i];
                if (dum == 0)
                    Pix(sg->sci.data,i,j) = 0.0F;
                else {
		    for (p=0; p < nimgs; p++) ipts[p] = p;
                    ipiksrt (&PIX(work,0,i,nimgs), dum, ipts);
                    if ((dum/2)*2 == dum) {
                        /* Even number of input images for this pixel */
                        Pix(sg->sci.data,i,j) = (PIX(work,dum/2-1,i,nimgs) +
						 PIX(work,dum/2,i,nimgs)) / 2.;
			expn = (exp2[ipts[dum/2-1]] + exp2[ipts[dum/2]]) / 2.;
                    } else {
                        Pix(sg->sci.data,i,j) = PIX(work,dum/2,i,nimgs);
			expn = exp2[ipts[dum/2]];
		    }
                }
                
                raw0 = Pix(sg->sci.data,i,j);
		exp2n = (expn > 0.) ? expn : 1.;
                Pix(sg->err.data,i,j) = (nse[1]+ raw0/gn[1] + SQ(scale*raw0)) /
					exp2n;
            } /* End loop over SECOND AMP used on pixels in the line */
        } /* End loop over lines */

    } else {

        /* use the minimum to construct the initial average */
        if (strncmp(par->initgues, "minimum", 3) != 0) {
            sprintf (MsgText,"Invalid INITGUES value %s, reset it to 'minimum'",
		     par->initgues);
            trlwarn (MsgText);
            strcpy (par->initgues, "minimum");
        }

        for (n = 0; n < nimgs; n++) {
            initHdr(&dqhdr);
            getHeader(ipdq[n],&dqhdr);
            for (j = 0; j < dim_y; j++) { 
                /* Set up the gain and noise values used for this line
		** in ALL images */
                if (j < ampy ) {
                    gn[0] = gain2[AMP_C];
                    gn[1] = gain2[AMP_D];
                    nse[0] = noise2[AMP_C];
                    nse[1] = noise2[AMP_D];
                } else {
                    gn[0] = gain2[AMP_A];
                    gn[1] = gain2[AMP_B];
                    nse[0] = noise2[AMP_A];
                    nse[1] = noise2[AMP_B];            
                }

                getFloatLine (ipsci[n], j, buf);
		getShortLine (ipdq[n],  j, bufdq);

		/* Rescale SCI data, if necessary */
		if (bunit[n] == COUNTRATE) {
		    for (i = 0; i < dim_x; i++) {
			 buf[i] *= efac[n];
		    }
		}

                /* AMPS C and D */
                for (i = 0; i < ampx; i++) {
                    raw = buf[i];
                    raw0 = (raw > 0.)? raw : 0.;
		    signal0 = ((raw - skyval[n]) > 0.) ? (raw - skyval[n]) : 0.;

		    if (efac[n] > 0.) {
                        val = (raw - skyval[n]) / efac[n];
		    } else {
			val = 0.;
		    }
                    if ((n == 0) || (val < Pix(sg->sci.data,i,j)) ) {
			if ((bufdq[i] & dqpat) == OK && (efac[n] > 0.)) {
                             Pix(sg->sci.data,i,j) = val;
                             /*Pix(sg->err.data,i,j) =
			      (nse[0]+ raw0/gn[0] + SQ(scale*raw0)) / exp2[n];*/
			     Pix(sg->err.data,i,j) =
			    (nse[0] + raw0/gn[0] + SQ(scale*signal0)) / exp2[n];
			} else {
			     Pix(sg->sci.data,i,j) = 0.;
			     Pix(sg->err.data,i,j) = 0.;
			}
                    } 
                } /* End of loop over FIRST AMP for this line in each image */

                for (i = ampx; i < dim_x; i++) {
                    raw = buf[i];
                    raw0 = (raw > 0.)? raw : 0.;
		    signal0 = ((raw - skyval[n]) > 0.) ? (raw - skyval[n]) : 0.;

		    if (efac[n] > 0.) {
                        val = (raw - skyval[n]) / efac[n];
		    } else {
			val = 0.;
		    }
                    if ((n == 0) ||
		       (val<Pix(sg->sci.data,i,j) && ((bufdq[i]&dqpat)==OK))) {
                        Pix(sg->sci.data,i,j) = val;
			if (efac[n] > 0.) {
                            Pix(sg->err.data,i,j) = 
			     (nse[1]+ raw0/gn[1] + SQ(scale*signal0)) / exp2[n];
			} else {
			    Pix(sg->err.data,i,j) = 0.;
			}
                    } 
                } /* End of loop over SECOND AMP for this line in each image */

            } /* End of loop over lines in image (y) */
            freeHdr(&dqhdr);
        } /* End of loop over images in set */
    }

    /* free the memory */
    free (ipts);
    free (npts);
    free (buf);
    free (exp2);
    free (bufdq);

    return (status);
}
Пример #16
0
// print text of current message
void PrintMessageText(CDrawPort *pdp)
{
  if (_acmMessages.Count()==0 ||
      _iActiveMessage>=_acmMessages.Count()||
      fComputerFadeValue<0.99f) {
    return;
  }

  SetFont2(pdp);

  // print subject
  CTString strSubject0;
  CTString strSubject1;
  CTString strSubject2;
  //strSubject.PrintF("%g", _fMsgAppearFade);
  const char *strSubject = _acmMessages[_iActiveMessage].cm_strSubject;
  INDEX ctSubjectLen = strlen(strSubject);
  INDEX ctToPrint = int(_fMsgAppearDelta*20.0f);
  for (INDEX iChar=0; iChar<ctSubjectLen; iChar++) {
    char strChar[2];
    strChar[0] = strSubject[iChar];
    strChar[1] = 0;
    if (iChar>ctToPrint) {
      NOTHING;
    } else if (iChar==ctToPrint) {
      strSubject2+=strChar;
    } else if (iChar==ctToPrint-1) {
      strSubject1+=strChar;
    } else {
      strSubject0+=strChar;
    }
  }
  PIX pixWidth0 = pdp->GetTextWidth(strSubject0);
  PIX pixWidth1 = pdp->GetTextWidth(strSubject1);
  pdp->PutText(strSubject0, _pixMarginI, _pixMarginJ-1, _colMedium);
  pdp->PutText(strSubject1, _pixMarginI+pixWidth0, _pixMarginJ-1, LerpColor( _colLight, _colMedium, 0.5f));
  pdp->PutText(strSubject2, _pixMarginI+pixWidth0+pixWidth1, _pixMarginJ-1, _colLight);

  pdp->DrawLine(0, PIX(_pixMarginJ*4), _boxMsgText.Size()(1), PIX(_pixMarginJ*4), _colBoxes);

  // fill in fresh player statistics
  if (strncmp(_acmMessages[_iActiveMessage].cm_strText, "$STAT", 5)==0) {
    _ppenPlayer->GetStats(_strStatsDetails, CST_DETAIL, _ctTextCharsPerRow);
    _acmMessages[_iActiveMessage].cm_ctFormattedWidth = 0;
  }
  // format text
  _acmMessages[_iActiveMessage].PrepareMessage(_ctTextCharsPerRow);

  SetFont1(pdp);
  INDEX ctLineToPrint = int(_fMsgAppearDelta*20.0f);
  // print it
  PIX pixJ = _pixMarginJ*4;
  for (INDEX iLine = _iTextLineOnScreen; 
    iLine<_iTextLineOnScreen+_ctTextLinesOnScreen;
    iLine++) {
    INDEX iPrintLine = iLine-_iTextLineOnScreen;
    if (iPrintLine>ctLineToPrint) {
      continue;
    }
    COLOR col = LerpColor( _colLight, _colMedium, Clamp( FLOAT(ctLineToPrint-iPrintLine)/3, 0.0f, 1.0f));
    pdp->PutText(_acmMessages[_iActiveMessage].GetLine(iLine),
      _pixMarginI, pixJ, col);
    pixJ+=_pixCharSizeJ;
  }

  PIXaabbox2D boxSliderSpace = GetTextSliderSpace();
  LCDDrawBox(0,0,boxSliderSpace, _colBoxes);
  PIXaabbox2D boxSlider = GetTextSliderBox();
  COLOR col = _colBoxes;
  PIXaabbox2D boxSliderTrans = boxSlider;
  boxSliderTrans+=_boxMsgText.Min();
  if (boxSliderTrans>=_vpixMouse) {
    col = LCDBlinkingColor(_colLight, _colDark);
  }
  pdp->Fill( boxSlider.Min()(1)+2,  boxSlider.Min()(2)+2,
             boxSlider.Size()(1)-4, boxSlider.Size()(2)-4, col);
}
Пример #17
0
int main( int argc, char** argv ) {
	
	int		cmd;
	float	desired[8][8]	= { {1,0,0,0,0,0,0,0},	// 0
								{0,1,0,0,0,0,0,0},	// 1
								{0,0,1,0,0,0,0,0},	// 2
								{0,0,0,1,1,0,0,0},	// 3 forward
								{0,0,0,1,1,0,0,0},	// 4 forward
								{0,0,0,0,0,1,0,0},	// 5
								{0,0,0,0,0,0,1,0},	// 6
								{0,0,0,0,0,0,0,1}};	// 7
						 
	CvPoint		p,q;
	CvScalar	line_color		= CV_RGB(0,0,255);
	CvScalar	out_color;

	const char* name_orig		= "Original: press q to save images";
	const char* name_ave		= "input";
	const char* name_weights	= "weights";
	
	const char*	inputCmdFile_name	= "./inputs/dataset1/commandlist.dat";
	const char*	outputFile_name		= "./outputs/output_";
	FILE*		outputFile;
	FILE*		inputCmdFile;
	char		inputName[64];
	char		outputName[64];

	
	CvCapture* capture = cvCreateCameraCapture(0) ;
		
	CvSize frame_size;
	CvScalar ave = cvScalar(1);
	
	
	CvRect  slice_rect;
	CvSize	slice_size;

	static	IplImage*	frame				= NULL;
	static	IplImage*	frame_g				= NULL;
	static	IplImage*	frame_small			= NULL;
	static	IplImage*	frame_weights		= NULL;
	static	IplImage*	frame_w_big			= NULL;
	static	IplImage*	frame_w_final		= NULL;
	static	IplImage*	frame_final			= NULL;	
	
	static	IplImage*	ave_image			= NULL;
//	static	IplImage *scale					= NULL;
	
	static	IplImage*	frame_slices[N_SLICES];



	float	inputs[(SIZE/N_SLICES)*SIZE];
	float	outputs[N_SLICES];
	int		choices[N_SLICES];
//	float	desired[N_SLICES];
//	float	desired[] = {0,0,0,1,1,0,0,0};										//XXX dummy test...	

	//Evo (int nNets, int nInputs, int nHidden, int nOuts)
	Evo*	evoSlice;

	int		ep;
	int		trial;
	int		stepCnt;

	int		flag = 0;

	char	c;
	int		i,j,k,s;
	float	tmp;

////////////////////////////////////////////////////////////////////////////////
// init stuff

	
	inputCmdFile	= fopen(inputCmdFile_name,"r");
	if (inputCmdFile == NULL) {printf("Unable to open: %s",inputCmdFile_name); return 0; }
	
	// create windows for looking at stuff
//	cvNamedWindow( name_slice,	CV_WINDOW_AUTOSIZE );
	cvNamedWindow( name_weights,	CV_WINDOW_AUTOSIZE );
	cvNamedWindow( name_ave,		CV_WINDOW_AUTOSIZE );
	cvNamedWindow( name_orig,		CV_WINDOW_AUTOSIZE );
	

//	frame_size	= cvSize(frame->width,frame->height);
	frame_size	= cvSize(SIZE,SIZE);

#ifdef USECAM
	// capture a frame so we can get an idea of the size of the source
	frame = cvQueryFrame( capture );
	if( !frame ) return 0;
#else
	sprintf(inputName,"./inputs/dataset1/image0000000000.jpg");
	frame = cvLoadImage(inputName, 0 );
	if( !frame ){ printf("ERROR OPENING: %s!!!\n",inputName); return 0;}
#endif


	allocateOnDemand( &frame_g,			cvSize(frame->width,frame->height), IPL_DEPTH_8U, 1 );
	allocateOnDemand( &frame_w_big,		cvSize(frame->width,frame->height), IPL_DEPTH_8U, 1 );	
	allocateOnDemand( &frame_w_final,	cvSize(frame->width,frame->height), IPL_DEPTH_8U, 3 );	
	allocateOnDemand( &frame_final,		cvSize(frame->width,frame->height+20), IPL_DEPTH_8U, 3 );	
	
	
	allocateOnDemand( &ave_image,		frame_size, IPL_DEPTH_8U, 1 );
	allocateOnDemand( &frame_small,		frame_size, IPL_DEPTH_8U, 1 );
	allocateOnDemand( &frame_weights,	frame_size, IPL_DEPTH_8U, 1 );


	slice_size = cvSize(ave_image->width/N_SLICES, ave_image->height);


	for (i=0;i<N_SLICES;i++) {
		allocateOnDemand( &frame_slices[i], slice_size, IPL_DEPTH_8U, 1);
	}


	for(trial=0;trial<N_TRIALS;trial++) {


		sprintf(outputName,"%s%d.txt", outputFile_name, trial);
		outputFile		= fopen(outputName,"w");


		// init each leariner
		evoSlice = (Evo*)malloc(sizeof(Evo)*N_SLICES);
		for(i=0;i<N_SLICES;i++) {
			evoSlice[i] = Evo(N_NETS, (SIZE/N_SLICES)*SIZE, N_HIDDEN, 1);
			evoSlice[i].choose();
			choices[i] = evoSlice[i].choose();
		}

		ep		= 0;
		stepCnt = 0;
		flag	= 0;


		while(1) {

	////////////////////////////////////////////////////////////////////////////////
	// Pre processing		

#if 0
			// make blank image...
			cvSet(ave_image, cvScalar(0));

	
			for (i=0;i<NF;i++) {
	
				// get image
#ifdef USECAM
				frame = cvQueryFrame( capture );
				if( !frame ) break;
#else				
				sprintf(inputName,"./inputs/dataset1/image%010d.jpg",stepCnt);
				frame = cvLoadImage(inputName, 0 );
				if( !frame ){ printf("ERROR OPENING: %s!!!\n",inputName); return 0;}
				stepCnt++;
#endif			
				// convert it to grey
				cvConvertImage(frame, frame_g );//, CV_CVTIMG_FLIP);


				// resize
				cvResize(frame_g, frame_small);

				
				// take difference
				cvSub(frame_small, ave_image, ave_image);

			}

			for(j=0;j<SIZE;j++) {
				for(k=0;k<SIZE;k++) {
					PIX(ave_image,k,j) = (char)(PIX(ave_image,k,j)*10);
				}
			}

#endif

#if 0
			frame = cvQueryFrame( capture );
			if( !frame ) break;
			cvConvertImage(frame, frame_g );
			cvResize(frame_g, frame_small);
			cvConvertImage(frame_small, ave_image );
#endif
		
#if 1
			sprintf(inputName,"./inputs/dataset1/image%010d.jpg",stepCnt);
			frame = cvLoadImage(inputName, 0 );
			if( !frame ){ printf("ERROR OPENING: %s!!!\n",inputName); break;}
			cvConvertImage(frame, frame_g );
			cvResize(frame_g, frame_small);
			cvConvertImage(frame_small, ave_image );
			
//			cvCanny(ave_image, ave_image, 50, 40,5);
			
#endif
		
		
	//		cvDilate(ave_image, ave_image,NULL,4);


	////////////////////////////////////////////////////////////////////////////////
	// Generate NN inputs


			// slice it up
			for (i=0;i<N_SLICES;i++) {
	
				slice_rect = cvRect(i*ave_image->width/N_SLICES, 0, ave_image->width/N_SLICES, ave_image->height);

				cvSetImageROI(ave_image, slice_rect);
				
				cvCopy(ave_image, frame_slices[i], NULL);

			}

			cvResetImageROI(ave_image);  // remove this when we don't care about looking at the ave

	////////////////////////////////////////////////////////////////////////////////
	// Evaluate NN
			if (stepCnt == N_LEARN)
				flag = 1;
	
			if( (flag == 1) && (stepCnt%N_LEARN == 0)) {	// every N_LEARN images switch
		
				ep++;
				fprintf(outputFile,"%d",ep);

				for(i=0;i<N_SLICES;i++) {
					evoSlice[i].replace();
					choices[i] = evoSlice[i].choose();
				
					fprintf(outputFile,"\t%1.3f",evoSlice[i].netPool[evoSlice[i].best()].grade);
				
				}
			
				fprintf(outputFile,"\n");
			
				if(ep >= N_EPISODES) break;
			
				// draw weights image
				for(s=0;s<N_SLICES;s++) {
		
					for(j=0;j<SIZE;j++) {
						for(k=0;k<(SIZE/N_SLICES);k++) {
				
							tmp = 0;
							for(i=0;i<N_HIDDEN;i++) {
								tmp += evoSlice[s].mutant->nodeHidden->w[(j*(SIZE/N_SLICES))+k+1];
							}
					
							PIX(frame_weights,k+(s*SIZE/N_SLICES),j) = (char)((tmp/N_HIDDEN)*255 + 127);
		//					printf("%d\t",(char)((tmp/N_HIDDEN)*255));
						}
					}
				}

				cvResize(frame_weights, frame_w_big, CV_INTER_LINEAR);
				cvConvertImage(frame_w_big, frame_w_final);
			
			}


			fscanf(inputCmdFile,"%d",&cmd);

			printf("\nTrial: %d   Episode: %d   Devin's cmd: %d\n",trial,ep,cmd);
			for(i=0;i<N_SLICES;i++)
				printf("%1.3f\t",desired[cmd][i]);
			printf("\n");
		

			for(i=0;i<N_SLICES;i++) {
	//			cvShowImage( name_slice, frame_slices[i] );

				// strip pixel data into a single array
				for(j=0;j<SIZE;j++) {
					for(k=0;k<(SIZE/N_SLICES);k++) {
						inputs[(j*(SIZE/N_SLICES))+k]	= (float)PIX(frame_slices[i],k,j)/255.0;
					}
				}


	//			printf("\n%d: Eval slice %d\n",stepCnt,i);
				outputs[i] = evoSlice[i].eval(inputs, &desired[cmd][i]);
	//			outputs[i] = desired[i];
				printf("%1.3f\t",outputs[i]);

			}
			printf("\n");

			for(i=0;i<N_SLICES;i++) {
				printf("%d\t",choices[i]);
			}
			printf("\n");

			for(i=0;i<N_SLICES;i++) {
				printf("%1.3f\t",evoSlice[i].mutant->grade);
			}
			printf("\n");


		
	////////////////////////////////////////////////////////////////////////////////
	// GUI stuff

		
		
		
			// copy input image into larger final image
			cvSetImageROI(frame_final, cvRect(0, 0, frame_w_big->width, frame_w_big->height));
			cvConvertImage(frame, frame_final);
			cvResetImageROI(frame_final);

			// draw slice markers
			for(i=1;i<N_SLICES;i++) {
				// on the final frame...
				p.x = (int)(i*frame_final->width/N_SLICES);
				p.y = 0;
				q.x = p.x;
				q.y = (int)frame_final->height;
				cvLine( frame_final, p, q, line_color, 2, CV_AA, 0 );

				// on the weights
				p.x = (int)(i*frame_w_final->width/N_SLICES);
				p.y = 0;
				q.x = p.x;
				q.y = (int)frame_w_final->height;
				cvLine( frame_w_final, p, q, line_color, 2, CV_AA, 0 );
			}

			// draw output indicators
			for(i=0;i<N_SLICES;i++) {
				out_color = CV_RGB(outputs[i]*255,0,0);
				p.x = (int)(i*frame_final->width/N_SLICES);
				p.y = (int)(frame_final->height-20);
				q.x = (int)(p.x+frame_final->width/N_SLICES);
				q.y = (int)(p.y+20);
				cvRectangle( frame_final, p, q, out_color, CV_FILLED, CV_AA, 0 );
			}
		
		
			cvShowImage( name_ave,		ave_image );
			cvShowImage( name_orig,		frame_final );
			cvShowImage( name_weights,	frame_w_final );
		
			c = cvWaitKey(2);
		
			if( c == 27 ) break;
			else if( c == 'q') {
				cvSaveImage("weights.jpg",frame_w_final);
				cvSaveImage("output.jpg",frame_final);
			}

			stepCnt++;
			if (stepCnt>=(N_STEPS-(N_STEPS%N_LEARN))) {
				stepCnt=0;
				rewind(inputCmdFile);
			}


		} // end while

		free(evoSlice);
		fclose(outputFile);
	} // end trial for

////////////////////////////////////////////////////////////////////////////////
// clean up
//	delete &evo;

	fclose(inputCmdFile);
	
	cvReleaseCapture(	&capture );
	cvDestroyWindow(	name_ave );
	cvDestroyWindow(	name_orig );
	cvDestroyWindow(	name_weights );
}
Пример #18
0
/*
Finish current check-image.
*/
void	reendcheck(picstruct *field, checkstruct *check)
  {
   char		*buf;
   size_t	padsize;

  padsize = 0;				/* To avoid gcc -Wall warnings */
  switch(check->type)
    {
    case CHECK_MINIBACKGROUND:
    case CHECK_MINIBACKRMS:
      return;

    case CHECK_IDENTICAL:
    case CHECK_BACKGROUND:
    case CHECK_BACKRMS:
    case CHECK_FILTERED:
    case CHECK_SUBTRACTED:
      free(check->pix);
      free(check->line);
      check->line = NULL;
      padsize = (FBSIZE -((check->npix*sizeof(PIXTYPE))%FBSIZE)) % FBSIZE;
      break;

    case CHECK_OBJECTS:
    case CHECK_APERTURES:
    case CHECK_SUBPSFPROTOS:
    case CHECK_PSFPROTOS:
    case CHECK_SUBPCPROTOS:
    case CHECK_PCPROTOS:
    case CHECK_PCOPROTOS:
    case CHECK_SUBPROFILES:
    case CHECK_PROFILES:
    case CHECK_ASSOC:
    case CHECK_PATTERNS:
      if (bswapflag)
        swapbytes(check->pix, sizeof(PIXTYPE), (int)check->npix);
      QFWRITE(check->pix,check->npix*sizeof(PIXTYPE),
		check->file,check->filename);
      free(check->pix);
      padsize = (FBSIZE-((check->npix*sizeof(PIXTYPE))%FBSIZE)) % FBSIZE;
      break;

    case CHECK_SEGMENTATION:
      if (bswapflag)
        swapbytes(check->pix, sizeof(ULONG), (int)check->npix);
      QFWRITE(check->pix,check->npix*sizeof(ULONG),
		check->file,check->filename);
      free(check->pix);
      padsize = (FBSIZE -((check->npix*sizeof(ULONG))%FBSIZE)) % FBSIZE;
      break;

    case CHECK_SUBOBJECTS:
      {
       int	y;

      for (y=field->ymin; y<field->ymax; y++)
        writecheck(check, &PIX(field, 0, y), field->width);
      free(check->pix);
      free(check->line);
      check->line = NULL;
      padsize = (FBSIZE -((check->npix*sizeof(PIXTYPE))%FBSIZE)) % FBSIZE;
      break;
      }

    case CHECK_MAPSOM:
      if (bswapflag)
        swapbytes(check->pix, sizeof(PIXTYPE), (int)check->npix);
      QFWRITE(check->pix,check->npix*sizeof(PIXTYPE),
		check->file,check->filename);
      free(check->pix);
      padsize = (FBSIZE -((check->npix*sizeof(USHORT))%FBSIZE)) % FBSIZE;
      break;

    default:
      error(EXIT_FAILURE, "*Internal Error* in ", "endcheck()!");
    }

  QCALLOC(buf, char, FBSIZE);
  if (padsize)
    QFWRITE (buf, padsize, check->file, check->filename);
  free(buf);

  return;
  }
Пример #19
0
// init select-on-render functionality
void InitSelectOnRender(PIX pixSizeI, PIX pixSizeJ)
{
  _pixSizeI = pixSizeI;
  _pixSizeJ = pixSizeJ;

  // if entity selecting not required
  if (_pselenSelectOnRender==NULL)
  {
    // if vertex selecting not requred
    if (_pselbvxtSelectOnRender==NULL) {
      // do nothing
      return;
    }
    // if not lasso and not alternative
    else if (_pavpixSelectLasso==NULL && !_bSelectAlternative) {
      // deselect all vertices
      _pselbvxtSelectOnRender->Clear();
    }
  }

  // if lasso selection is not on, or is invalid
  if (_pavpixSelectLasso==NULL || _pavpixSelectLasso->Count()<3
    || pixSizeI<2 || pixSizeJ<2) {
    // do nothing
    return;
  }

  SLONG slMaxOffset = pixSizeI*pixSizeJ-1;

  // allocate lasso buffer
  _pubLassoBuffer = (UBYTE*)AllocMemory(_pixSizeI*_pixSizeJ);
  // clear it
  memset(_pubLassoBuffer, 0, _pixSizeI*_pixSizeJ);

  // for each line in lasso
  INDEX ctpt = _pavpixSelectLasso->Count();
  for (INDEX ipt=0; ipt<ctpt; ipt++) {
    // get its points
    INDEX ipt0 = ipt;
    INDEX ipt1 = (ipt+1)%ctpt;
    // get their coordinates
    PIX pixI0 = (*_pavpixSelectLasso)[ipt0](1);
    PIX pixJ0 = (*_pavpixSelectLasso)[ipt0](2);
    PIX pixI1 = (*_pavpixSelectLasso)[ipt1](1);
    PIX pixJ1 = (*_pavpixSelectLasso)[ipt1](2);
    // if any of the coordinates is outside of window
    if (pixI0<0 || pixI0>=_pixSizeI || pixI1<0 || pixI1>=_pixSizeI ||
      pixJ0<0 || pixJ0>=_pixSizeJ || pixJ1<0 || pixJ1>=_pixSizeJ) {
      // skip this line
      continue;
    }

    // if line is horizontal
    if (pixJ0==pixJ1) {
      // skip it
      continue;
    // if line goes upwards
    } else if (pixJ0>pixJ1) {
      // make it go downwards
      Swap(pixI0, pixI1);
      Swap(pixJ0, pixJ1);
    }

    // calculate step
    FIX16_16 xStep = FIX16_16(FLOAT(pixI1-pixI0)/(pixJ1-pixJ0));
    // start in first row
    FIX16_16 xI = FIX16_16(pixI0);
    
    // for each row
    for(PIX pixJ = pixJ0; pixJ<pixJ1; pixJ++) {
      // get offset
      SLONG slOffset = pixJ*_pixSizeI+PIX(xI);
      // if offset is valid
      if (slOffset>=0 && slOffset<=slMaxOffset) {
        // invert the pixel in that row
        _pubLassoBuffer[slOffset] ^= 0xFF;
      }
      // step the line
      xI+=xStep;
    }
  }

  // for each row in lasso buffer
  for(PIX pixJ = 0; pixJ<_pixSizeJ; pixJ++) {
    // for each pixel in the row, except the last one
    UBYTE *pub = _pubLassoBuffer+pixJ*_pixSizeI;
    for(PIX pixI = 0; pixI<_pixSizeI-1; pixI++) {
      // xor it to the next one
      pub[1]^=pub[0];
      pub++;
    }
  }
}
Пример #20
0
Файл: lcd.c Проект: n0p/f1rmware
//# MENU lcd
void lcd_menu() {
    getInputWaitRelease();
    lcdClear();
    lcdPrintln("LCD:");
    lcdDisplay();
    ON(LED1);

    uint16_t x,y;
    uint8_t rgb=0;
    uint8_t ct=0x3a;
    uint16_t rgba[]= { RGB(0xff,0,0),   RGB(0,0xff,0),   RGB(0,0,0xff),
                       RGB(0,0xff,0xff),RGB(0xff,0,0xff),RGB(0xff,0xff,0),
                       RGB(0xff,0xff,0xff),0
                     };
    while(1) {
        switch(getInputWaitRepeat()) {
        case BTN_DOWN:
            lcd_select();
            lcdWrite(TYPE_CMD,0x3a);
            lcdWrite(TYPE_DATA,5);
            lcdWrite(TYPE_CMD,0x2C);
            for (y=0; y<128; y++) {
                for (x=0; x<RESX; x++) {
                    if (x<20) {
                        if(y<64) {
                            PIX(0xff,(0xff-(0xff&(y<<2))),(0xff-(0xff&(y<<2))));
                        } else {
                            PIX((0xff-(0xff&(y<<2))),0,0);
                        };
                    } else if (x <40) {
                        if(y<64) {
                            PIX((0xff-(0xff&(y<<2))),0xff,(0xff-(0xff&(y<<2))));
                        } else {
                            PIX(0,(0xff-(0xff&(y<<2))),0);
                        };
                    } else if (x <60) {
                        if(y<64) {
                            PIX((0xff-(0xff&(y<<2))),(0xff-(0xff&(y<<2))),0xff);
                        } else {
                            PIX(0,0,(0xff-(0xff&(y<<2))));
                        };
                    } else if (x <80) {
                        if(y<64) {
                            PIX(((0xff&(y<<2))),0,0);
                        } else {
                            PIX(0xff,((0xff&(y<<2))),((0xff&(y<<2))));
                        };
                    } else if (x <100) {
                        if(y<64) {
                            PIX(0,((0xff&(y<<2))),0);
                        } else {
                            PIX(((0xff&(y<<2))),0xff,((0xff&(y<<2))));
                        };
                    } else if (x <120) {
                        if(y<64) {
                            PIX(0,0,((0xff&(y<<2))));
                        } else {
                            PIX(((0xff&(y<<2))),((0xff&(y<<2))),0xff);
                        };
                    } else {
                        PIX(0,0,0);
                    }
                };
            };
            for (y=128; y<RESY; y++) {
                for (x=0; x<RESX; x++) {
                    PIX(0,0,0);
                };
            };
            lcd_deselect();
            break;
        case BTN_LEFT:
            ct--;
            lcd_select();
            lcdWrite(TYPE_CMD,0x25);
            lcdWrite(TYPE_DATA, ct);
            lcd_deselect();
            break;
        case BTN_RIGHT:
            ct++;
            lcd_select();
            lcdWrite(TYPE_CMD,0x25);
            lcdWrite(TYPE_DATA, ct);
            lcd_deselect();
            break;
        case BTN_UP:
            lcd_select();
            lcdWrite(TYPE_CMD,0x3a);
            lcdWrite(TYPE_DATA,5);
            lcdWrite(TYPE_CMD,0x2C);
            if(rgb==0) {
                for (y=0; y<RESY; y++) {
                    for (x=0; x<RESX; x++) {
                        if(x==0 || x==RESX-1 || y==0 || y==RESY-1) {
                            PIX(0xff,0,0);
                        } else if(x==1 || x==RESX-2 || y==1 || y==RESY-2) {
                            PIX(0xff,0xff,0);
                        } else if(x==2 || x==RESX-3 || y==2 || y==RESY-3) {
                            PIX(0,0,0xff);
                        } else {
                            PIX(0xff,0xff,0xff);
                        };
                    };
                };
            } else {
                for (y=0; y<RESY; y++) {
                    for (x=0; x<RESX; x++) {
                        lcdWrite(TYPE_DATA,rgba[rgb-1]>>8);
                        lcdWrite(TYPE_DATA,rgba[rgb-1]&0xff);
                    };
                };
            };
            lcd_deselect();
            rgb=(rgb+1)%(1+(sizeof(rgba)/sizeof(*rgba)));
            break;
        case BTN_ENTER:
            lcd_select();
            lcdWrite(TYPE_CMD,0x3a);
            lcdWrite(TYPE_DATA,2);
            lcd_deselect();
            return;
        };
        getInputWaitRelease();
    };
};
Пример #21
0
void blur(ofPixels &pix) {
    #define PIX(x, y) pix.getColor(ofClamp(x,0,1023), ofClamp(y,0,767))
    #define RAD 0.2
    // blur X
    for (int x = 0; x < 1024; ++x)
        for (int y = 0; y < 768; ++y)
        {
            ofColor col(0);
            col += PIX(x - 4*RAD, y) * 0.000215825;
            col += PIX(x - 3*RAD, y) * 0.00579007;
            col += PIX(x - 2*RAD, y) * 0.059897;
            col += PIX(x - 1*RAD, y) * 0.241811;
            col += PIX(x        , y) * 0.384572;
            col += PIX(x + 1*RAD, y) * 0.241811;
            col += PIX(x + 2*RAD, y) * 0.059897;
            col += PIX(x + 3*RAD, y) * 0.00579007;
            col += PIX(x + 4*RAD, y) * 0.000215825;
            pix.setColor(x, y, col);
        }
    // blur Y
    for (int x = 0; x < 1024; ++x)
        for (int y = 0; y < 768; ++y)
        {
            ofColor col(0);
            col += PIX(x, y - 4*RAD) * 0.000215825;
            col += PIX(x, y - 3*RAD) * 0.00579007;
            col += PIX(x, y - 2*RAD) * 0.059897;
            col += PIX(x, y - 1*RAD) * 0.241811;
            col += PIX(x, y        ) * 0.384572;
            col += PIX(x, y + 1*RAD) * 0.241811;
            col += PIX(x, y + 2*RAD) * 0.059897;
            col += PIX(x, y + 3*RAD) * 0.00579007;
            col += PIX(x, y + 4*RAD) * 0.000215825;
            pix.setColor(x, y, col);
        }
}
Пример #22
0
// Triscan scaling to 2x
//	derivative of scale2x -- scale2x.sf.net
// The name expands to either
//		Scale_TriScanFilter (for plain C) or
//		Scale_MMX_TriScanFilter (for MMX)
//		[others when platforms are added]
void
SCALE_(TriScanFilter) (SDL_Surface *src, SDL_Surface *dst, SDL_Rect *r)
{
	int x, y;
	const int w = src->w, h = src->h;
	int xend, yend;
	int dsrc, ddst;
	SDL_Rect *region = r;
	SDL_Rect limits;
	SDL_PixelFormat *fmt = dst->format;
	const int sp = src->pitch, dp = dst->pitch;
	const int bpp = fmt->BytesPerPixel;
	const int slen = sp / bpp, dlen = dp / bpp;
	// for clarity purposes, the 'pixels' array here is transposed
	Uint32 pixels[3][3];
	Uint32 *src_p = (Uint32 *)src->pixels;
	Uint32 *dst_p = (Uint32 *)dst->pixels;

	int prevline, nextline;

	// these macros are for clarity; they make the current pixel (0,0)
	// and allow to access pixels in all directions
	#define PIX(x, y)   (pixels[1 + (x)][1 + (y)])

	#define TRISCAN_YUV_MED     100
	// medium tolerance pixel comparison
	#define TRISCAN_CMPYUV(p1, p2) \
			(PIX p1 == PIX p2 || SCALE_CMPYUV (PIX p1, PIX p2, TRISCAN_YUV_MED))


	SCALE_(PlatInit) ();

	// expand updated region if necessary
	// pixels neighbooring the updated region may
	// change as a result of updates
	limits.x = 0;
	limits.y = 0;
	limits.w = src->w;
	limits.h = src->h;
	Scale_ExpandRect (region, 1, &limits);

	xend = region->x + region->w;
	yend = region->y + region->h;
	dsrc = slen - region->w;
	ddst = (dlen - region->w) * 2;

	// move ptrs to the first updated pixel
	src_p += slen * region->y + region->x;
	dst_p += (dlen * region->y + region->x) * 2;

	for (y = region->y; y < yend; ++y, dst_p += ddst, src_p += dsrc)
	{
		if (y > 0)
			prevline = -slen;
		else
			prevline = 0;

		if (y < h - 1)
			nextline = slen;
		else
			nextline = 0;
	
		// prime the (tiny) sliding-window pixel arrays
		PIX( 1,  0) = src_p[0];

		if (region->x > 0)
			PIX( 0,  0) = src_p[-1];
		else
			PIX( 0,  0) = PIX( 1,  0);

		for (x = region->x; x < xend; ++x, ++src_p, dst_p += 2)
		{
			// slide the window
			PIX(-1,  0) = PIX( 0,  0);

			PIX( 0, -1) = src_p[prevline];
			PIX( 0,  0) = PIX( 1,  0);
			PIX( 0,  1) = src_p[nextline];

			if (x < w - 1)
				PIX( 1,  0) = src_p[1];
			else
				PIX( 1,  0) = PIX( 0,  0);
			
			if (!TRISCAN_CMPYUV (( 0, -1), ( 0,  1)) &&
				!TRISCAN_CMPYUV ((-1,  0), ( 1,  0)))
			{
				if (TRISCAN_CMPYUV ((-1,  0), ( 0, -1)))
					dst_p[0] = Scale_Blend_11 (PIX(-1, 0), PIX(0, -1));
				else
					dst_p[0] = PIX(0, 0);

				if (TRISCAN_CMPYUV (( 1,  0), ( 0, -1)))
					dst_p[1] = Scale_Blend_11 (PIX(1, 0), PIX(0, -1));
				else
					dst_p[1] = PIX(0, 0);

				if (TRISCAN_CMPYUV ((-1,  0), ( 0,  1)))
					dst_p[dlen] = Scale_Blend_11 (PIX(-1, 0), PIX(0, 1));
				else
					dst_p[dlen] = PIX(0, 0);

				if (TRISCAN_CMPYUV (( 1,  0), ( 0,  1)))
					dst_p[dlen+1] = Scale_Blend_11 (PIX(1, 0), PIX(0, 1));
				else
					dst_p[dlen+1] = PIX(0, 0);
			}
			else
			{
				dst_p[0]      = PIX(0, 0);
				dst_p[1]      = PIX(0, 0);
				dst_p[dlen]   = PIX(0, 0);
				dst_p[dlen+1] = PIX(0, 0);
			}
		}
	}

	SCALE_(PlatDone) ();
}
/**
 * Image labeling algorithm.
 *
 *  @param im  pointer to input image of type PIXEL
 *  @param width  width input image in pixels
 *  @param height  height input image in pixels
 *  @param connectivty  number of connectivity directions (4 or 8)
 *  @param minsize  smallest allowable blob size, they get subsumed into the parent blob
 *  @param limage pointer to label image, of same size as \p im (output)
 *  @param parent_out pointer to pointer for return of an array of region parents.  Can be NULL. (output)
 *  @param color_out pointer to pointer for return of an array of region color. Can be NULL. (output)
 *  @param edge_out pointer to pointer for return of an array of region edge points.  Can be NULL. (output)
 *  @return the number of regions found
 */
static int 
ilabel(PIXEL *im, int width, int height, int connectivity, int minsize,
    LABEL *limage,
    LABEL **parent_out, PIXEL **color_out, unsigned int **edge_out)
{
    int     *blobsize, row, col, i, j, nlabels;
    int newlabel;
    LABEL   *lmap2;
    LABEL   prevlab, curlab;
    LABEL   *parents;
    PIXEL   curpix, prevpix;
    PIXEL   *color;
    unsigned int    *edge;
    int     maxlabel = width*height;

    /* allocate label map and initialize to zero */
    lmap = (LABEL *)mxCalloc(maxlabel, sizeof(LABEL));
    /* region size */
    blobsize = (int *)mxCalloc(maxlabel, sizeof(int));

    if (parent_out)
        parents = (LABEL *)mxCalloc(maxlabel, sizeof(LABEL));
    if (color_out)
        color = (PIXEL *)mxCalloc(maxlabel, sizeof(PIXEL));
    if (edge_out)
        edge = (unsigned int *)mxCalloc(maxlabel, sizeof(unsigned int));

    

    /*
     * Blob labels are ints >= 1
     * newlabel holds the most recently assigned label value.
     * labels are unique and never recycled.
     *
     * When 2 blobs merge: A := A + B an entry is placed in the label map
     *     lmap[B] = A indicating that all pixels that were B are now A.
     * If lmap[X] = 0 then X is unmerged, X is X
     * It is possible that a later merge: C = C + A
     *     lmap[A] = C indicating that all As are now Cs
     * A pixel that was once B is mapped to A, then to C, but lmap[C] is 0 so
     * the indirection stops there.  B --> A --> C
     *
     * Resolving the indirection is the job of lresolve()
     *      lresolve(A) --> C
     *      lresolve(B) --> C
     *      lresolve(C) --> C
     */

    for (row=0; row<height; row++) {
        for (col=0; col<width; col++) {
            curpix = PIX(im,row,col);
#ifdef  DEBUG
            printf("%2d ", curpix);
#endif
        }
#ifdef  DEBUG
        printf("\n");
#endif
    }

    /*
     * first pass labelling loop.  Only does 4-way connectivity
     */
    newlabel = 0;
    for (row=0; row<height; row++) {
        prevlab = UNKNOWN;
        for (col=0; col<width; col++) {
            curpix = PIX(im,row,col);
            curlab = UNKNOWN;       // start with no known label
            if (col > 0) {
                prevpix = PIX(im,row,col-1);
                /* if no change in pixel value then inherit label from left */
                if (curpix == prevpix)
                    curlab = prevlab;
            }

            
#ifdef  DEBUG
                printf("(%d,%d) cp=%d, pp=%d, cl=%d, pl=%d\n", row, col, curpix, prevpix,
                    curlab, prevlab);
#endif
            /*
             * check whether a label merge should happen, adjacent
             * pixels with the same value but different labels
             * means that one should change.
             *
             * merge can only happen on second row onwards 
             */
            if (row > 0) {
                if (    (PIX(im,row-1,col) == curpix) &&
                    (lresolve(PIX(limage,row-1,col)) != curlab)
                ) {
                    /* we have a label assignment from N */
                    int newlabel;
                    
                    newlabel = lresolve(PIX(limage,row-1,col));
                    /*
                    newlabel = PIX(lim,row-1,col);
                    */

#ifdef  DEBUG
                    printf("mergeN(%d,%d): %d becomes %d: curpix=%d, prevpix=%d\n",
                        row, col, curlab, newlabel, curpix, PIX(im,row-1,col));
#endif
                    // newlabel dominates
                    if (curlab != UNKNOWN) {
                        lmap[curlab] = newlabel;
                        blobsize[newlabel] += blobsize[curlab];
                        //if (edge[curlab] < edge[newlabel])
                            //edge[newlabel] = edge[curlab];
                        if (parents[curlab] == 0)
                            parents[newlabel] = 0;
                    }
                    curlab = newlabel;

                } else if (
                    connectivity == 8 &&
                    (col > 0) &&
                    (PIX(im,row-1,col-1) == curpix) &&
                    (lresolve(PIX(limage,row-1,col-1)) != curlab)
                ) {
                    //  TODO: factorize these two merge cases

                    /* we have a merge to NW */
                    int newlabel;
                    
                    newlabel = lresolve(PIX(limage,row-1,col-1));
                    /*
                    newlabel = PIX(lim,row-1,col);
                    */

#ifdef  DEBUG
                    printf("mergeNW(%d,%d): %d becomes %d\n",
                        row, col, curlab, newlabel);
#endif
                    if (curlab != UNKNOWN)
                        lmap[curlab] = newlabel;
                    if (parents[curlab] == 0)
                        parents[newlabel] = 0;
                    //if (edge[curlab] < edge[newlabel])
                        //edge[newlabel] = edge[curlab];
                    blobsize[newlabel] += blobsize[curlab];
                    curlab = newlabel;

                } else if (
                    connectivity == 8 &&
                    (col < (width-1)) &&
                    (PIX(im,row-1,col+1) == curpix) &&
                    (lresolve(PIX(limage,row-1,col+1)) != curlab)
                ) {
                    /* we have a merge to NE */
                    int newlabel;
                    
                    newlabel = lresolve(PIX(limage,row-1,col+1));
                    /*
                    newlabel = PIX(lim,row-1,col);
                    */

#ifdef  DEBUG
                    printf("mergeNE(%d,%d): %d becomes %d\n",
                        row, col, curlab, newlabel);
#endif
                    if (curlab != UNKNOWN)
                        lmap[curlab] = newlabel;
                    blobsize[newlabel] += blobsize[curlab];
                    //if (edge[curlab] < edge[newlabel])
                        //edge[newlabel] = edge[curlab];
                    curlab = newlabel;

                }

            }

            if ((row > 0) && (col > 0)) {
                /*
                 * check for enclosure
                 */
                int left, above, northwest;

                left = prevlab;
                above = lresolve( PIX(limage,row-1,col) );
                northwest = lresolve( PIX(limage,row-1,col-1) );
                if (    (left == curlab) &&
                    (above == curlab) &&
                    (northwest != curlab)
                ) {
#ifdef  DEBUG
                    printf("(%d,%d): label %d encloses %d\n",
                        row, col,
						curlab, northwest);
#endif
					/* we have an enclosure */
                    if (blobsize[curlab] > THRESH) {
                        // mark the parent of this blob
                        parents[northwest] = curlab;
                        //edge[northwest] = (row-1) + height*(col-1) + 1;
                        //printf("edge is %d\n", edge[northwest]);
                    } else {
                        // it's a runt, merge it with its parent
                        lmap[curlab] = northwest;
                    }
                }
            }

            /* if label still not known, assign new */
            if (curlab == UNKNOWN) {
                curlab = NEWLABEL;
                color[curlab] = curpix;
                edge[curlab] = row + height*col + 1;
                //printf("color %d %f\n", curlab, curpix);
#ifdef  DEBUG
                printf("new label(%d,%d): %d\n", 
                    row, col, curlab);
#endif
            }
            blobsize[curlab] += 1;

            PIX(limage,row,col) = curlab;
            prevlab = curlab;
            prevpix = curpix;
        }
    }

#ifdef  DEBUG
    printf("max lim is %d\n", newlabel);
#endif

    /*
     * The label indirection map can have have quite long chains of indirection
     * as the result of region merges.
     *
     * We pass over the map, and set each entry to its final value, or 0 meaning
     * that it is not indirected.
     *

     */

     /*
      * create a new label map that maps all old labels to new consecutive labels
      */
    lmap2 = (LABEL *)mxCalloc(newlabel+1, sizeof(LABEL));

     /*
      * Create a vector of all the final label values, ie. lmap[i] == 0
      */
#ifdef  DEBUG
    printf("----------------------\nlmap:\n");
#endif
    for (i=1,nlabels=0; i<=newlabel; i++) {
#ifdef  DEBUG
        printf("(%d) = %d\n", i, lmap[i]);
#endif
        if (lmap[i] == 0) 
            lmap2[i] = ++nlabels;   /* assign new sequential label */
    }
    /*
     * now resolve each labels appear in the
     * labelled image, 
     */
    for (i=0; i<=newlabel; i++)
        if (lmap[i] != 0) {
            j = lresolve(i);
            lmap2[i] = lmap2[j];
        }
#ifdef  DEBUG
    printf("----------------------\nlmap2:\n");
    for (i=1; i<=newlabel; i++)
        printf("old(%d) -> %d\n", i, lmap2[i]);
#endif

#ifdef  DEBUG
    printf("----------------------\nparents:\n");
    for (i=1; i<=newlabel; i++)
        printf("parent[%d] = %d\n", i, parents[i]);
#endif

    /*
     * resolve the labels in the parent array and assign to double proc
     * output array
     */
    if (parent_out) {
        LABEL   *lab;

        lab = mxCalloc(nlabels, sizeof(LABEL));
        for (i=1; i<=newlabel; i++) {
            LABEL   par = parents[i], child;

            if (par) {
                child = lmap2[i];
                par = lmap2[par];
                lab[child-1] = par;
                //printf("parent [%d] = %d\n", child, par);
            }
        }
        mxFree(parents);
        *parent_out = lab;
    }

    if (color_out || edge_out) {
        PIXEL   *c;
        unsigned int    *e;

        c = (PIXEL *)mxCalloc(nlabels, sizeof(PIXEL));
        e = (unsigned int *)mxCalloc(nlabels, sizeof(unsigned int));
        for (i=1; i<=newlabel; i++) {
            LABEL     l;

            l = lmap2[i];
            c[l-1] = color[i];
            if (e[l-1] == 0)
                e[l-1] = edge[i];
            //printf("edge %d %d %d\n", i, l, edge[i]);
            //printf("color [%d] = %f\n", l, color[i]);
        }
        if (color_out) {
            mxFree(color);
            *color_out = c;
        }
        if (edge_out) {
            mxFree(edge);
            *edge_out = e;
        }
   }

    /*
     * resolve the labels in the integer labelled image and assign
     * to the double prec. output image
     */
    for (row=0; row<height; row++)
        for (col=0; col<width; col++)
            PIX(limage,row,col) = lmap2[ PIX(limage,row,col) ];

    mxFree(lmap);
    mxFree(lmap2);
    mxFree(blobsize);

    return(nlabels);
}
Пример #24
0
/****************************** scanimage ************************************
PROTO   void scanimage(picstruct *field, picstruct *dfield, picstruct *ffield,
        picstruct *wfield, picstruct *dwfield)
PURPOSE Scan of the large pixmap(s). Main loop and heart of the program.
INPUT   Measurement field pointer,
        Detection field pointer,
        Flag field pointer,
        Measurement weight-map field pointer,
        Detection weight-map field pointer,
OUTPUT  -.
NOTES   -.
AUTHOR  E. Bertin (IAP)
VERSION 21/12/2011
 ***/
void	scanimage(picstruct *field, picstruct *dfield, picstruct **pffield,
		int nffield, picstruct *wfield, picstruct *dwfield)

  {
   static infostruct	curpixinfo, *info, *store,
			initinfo, freeinfo, *victim;
   picstruct		*ffield;
   checkstruct		*check;
   objliststruct       	objlist;
   objstruct		*cleanobj;
   pliststruct		*pixel, *pixt;
   picstruct		*cfield, *cdwfield;

   char			*marker, newmarker, *blankpad, *bpt,*bpt0;
   int			co, i,j, flag, luflag,pstop, xl,xl2,yl, cn,
			nposize, stacksize, w, h, blankh, maxpixnb,
			varthreshflag, ontotal;
   short	       	trunflag;
   PIXTYPE		thresh, relthresh, cdnewsymbol, cdwthresh,wthresh,
			*scan,*dscan,*cdscan,*dwscan,*dwscanp,*dwscann,
			*cdwscan,*cdwscanp,*cdwscann,*wscand,
			*scant, *wscan,*wscann,*wscanp;
   FLAGTYPE		*pfscan[MAXFLAG];
   status		cs, ps, *psstack;
   int			*start, *end, ymax;

/* Avoid gcc -Wall warnings */
  scan = dscan = cdscan = cdwscan = cdwscann = cdwscanp
	= dwscan = dwscann = dwscanp
	= wscan = wscann = wscanp = NULL;
  victim = NULL;			/* Avoid gcc -Wall warnings */
  blankh = 0;				/* Avoid gcc -Wall warnings */
/*----- Beginning of the main loop: Initialisations  */
  thecat.ntotal = thecat.ndetect = 0;

/* cfield is the detection field in any case */
  cfield = dfield? dfield:field;

/* cdwfield is the detection weight-field if available */
  cdwfield = dwfield? dwfield:(prefs.dweight_flag?wfield:NULL);
  cdwthresh = cdwfield ? cdwfield->weight_thresh : 0.0;
  if (cdwthresh>BIG*WTHRESH_CONVFAC);
    cdwthresh = BIG*WTHRESH_CONVFAC;
  wthresh = wfield? wfield->weight_thresh : 0.0;

/* If WEIGHTing and no absolute thresholding, activate threshold scaling */
  varthreshflag = (cdwfield && prefs.thresh_type[0]!=THRESH_ABSOLUTE);
  relthresh = varthreshflag ? prefs.dthresh[0] : 0.0;/* To avoid gcc warnings*/
  w = cfield->width;
  h = cfield->height;
  objlist.dthresh = cfield->dthresh;
  objlist.thresh = field->thresh;
  cfield->yblank = 1;
  field->y = field->stripy = 0;
  field->ymin = field->stripylim = 0;
  field->stripysclim = 0;
  if (dfield)
    {
    dfield->y = dfield->stripy = 0;
    dfield->ymin = dfield->stripylim = 0;
    dfield->stripysclim = 0;
    }
  if (nffield)
    for (i=0; i<nffield; i++)
      {
      ffield = pffield[i];
      ffield->y = ffield->stripy = 0;
      ffield->ymin = ffield->stripylim = 0;
      ffield->stripysclim = 0;
      }
  if (wfield)
    {
    wfield->y = wfield->stripy = 0;
    wfield->ymin = wfield->stripylim = 0;
    wfield->stripysclim = 0;
    }
  if (dwfield)
    {
    dwfield->y = dwfield->stripy = 0;
    dwfield->ymin = dwfield->stripylim = 0;
    dwfield->stripysclim = 0;
    }

/*Allocate memory for buffers */
  stacksize = w+1;
  QMALLOC(info, infostruct, stacksize);
  QCALLOC(store, infostruct, stacksize);
  QMALLOC(marker, char, stacksize);
  QMALLOC(dumscan, PIXTYPE, stacksize);
  QMALLOC(psstack, status, stacksize);
  QCALLOC(start, int, stacksize);
  QMALLOC(end, int, stacksize);
  blankpad = bpt = NULL;
  lutzalloc(w,h);
  allocparcelout();

/* Some initializations */

  thresh = objlist.dthresh;
  initinfo.pixnb = 0;
  initinfo.flag = 0;
  initinfo.firstpix = initinfo.lastpix = -1;

  for (xl=0; xl<stacksize; xl++)
    {
    marker[xl]  = 0 ;
    dumscan[xl] = -BIG ;
    }

  co = pstop = 0;
  objlist.nobj = 1;
  curpixinfo.pixnb = 1;

/* Init cleaning procedure */
  initclean();

/*----- Allocate memory for the pixel list */
  init_plist();

  if (!(pixel = objlist.plist = malloc(nposize=prefs.mem_pixstack*plistsize)))
    error(EXIT_FAILURE, "Not enough memory to store the pixel stack:\n",
        "           Try to decrease MEMORY_PIXSTACK");

/*----- at the beginning, "free" object fills the whole pixel list */
  freeinfo.firstpix = 0;
  freeinfo.lastpix = nposize-plistsize;
  pixt = pixel;
  for (i=plistsize; i<nposize; i += plistsize, pixt += plistsize)
    PLIST(pixt, nextpix) = i;
  PLIST(pixt, nextpix) = -1;

/* Allocate memory for other buffers */
  if (prefs.filter_flag)
    {
    QMALLOC(cdscan, PIXTYPE, stacksize);
    if (cdwfield)
      {
      QCALLOC(cdwscan, PIXTYPE, stacksize);
      if (PLISTEXIST(wflag))
        {
        QCALLOC(cdwscanp, PIXTYPE, stacksize);
        QCALLOC(cdwscann, PIXTYPE, stacksize);
        }
      }
/*-- One needs a buffer to protect filtering if source-blanking applies */
    if (prefs.blank_flag)
      {
      blankh = thefilter->convh/2+1;
      QMALLOC(blankpad, char, w*blankh);
      cfield->yblank -= blankh;
      if (dfield)
        field->yblank = cfield->yblank;
      bpt = blankpad;
      }
    }

/*----- Here we go */
  for (yl=0; yl<=h;)
    {
    ps = COMPLETE;
    cs = NONOBJECT;
    if (yl==h)
      {
/*---- Need an empty line for Lutz' algorithm to end gracely */
      if (prefs.filter_flag)
        {
        free(cdscan);
        if (cdwfield)
          {
          if (PLISTEXIST(wflag))
            {
            free(cdwscanp);
            free(cdwscann);
            cdwscanp = cdwscan;
            }
          else
            free(cdwscan);
          }
        }
      cdwscan = cdwscann = cdscan = dumscan;
      }
    else
      {
      if (nffield)
        for (i=0; i<nffield; i++)
          {
          ffield = pffield[i];
          pfscan[i] = (ffield->stripy==ffield->stripysclim)?
		  (FLAGTYPE *)loadstrip(ffield, (picstruct *)NULL)
		: &ffield->fstrip[ffield->stripy*ffield->width];
          }
      if (wfield)
        {
/*------ Copy the previous weight line to track bad pixel limits */
        wscan = (wfield->stripy==wfield->stripysclim)?
		  (PIXTYPE *)loadstrip(wfield, (picstruct *)NULL)
		: &wfield->strip[wfield->stripy*wfield->width];
        if (PLISTEXIST(wflag))
          {
          if (yl>0)
            wscanp = &wfield->strip[((yl-1)%wfield->stripheight)*wfield->width];
          if (yl<h-1)
            wscann = &wfield->strip[((yl+1)%wfield->stripheight)*wfield->width];
          }
        }
      scan = (field->stripy==field->stripysclim)?
		  (PIXTYPE *)loadstrip(field, wfield)
		: &field->strip[field->stripy*field->width];
      if (dwfield)
        {
        dwscan = (dwfield->stripy==dwfield->stripysclim)?
		  (PIXTYPE *)loadstrip(dwfield,
				dfield?(picstruct *)NULL:dwfield)
		: &dwfield->strip[dwfield->stripy*dwfield->width];
        if (PLISTEXIST(wflag))
          {
          if (yl>0)
            dwscanp = &dwfield->strip[((yl-1)%dwfield->stripheight)
			*dwfield->width];
          if (yl<h-1)
            dwscann = &dwfield->strip[((yl+1)%dwfield->stripheight)
			*dwfield->width];
          }
        }
      else
        {
        dwscan = wscan;
        if (PLISTEXIST(wflag))
          {
          dwscanp = wscanp;
          dwscann = wscann;
          }
        }
      if (dfield)
        dscan = (dfield->stripy==dfield->stripysclim)?
		  (PIXTYPE *)loadstrip(dfield, dwfield)
		: &dfield->strip[dfield->stripy*dfield->width];
      else
        dscan = scan;

      if (prefs.filter_flag)
        {
        filter(cfield, cdscan, cfield->y);
        if (cdwfield)
          {
          if (PLISTEXIST(wflag))
            {
            if (yl==0)
              filter(cdwfield, cdwscann, yl);
            wscand = cdwscanp;
            cdwscanp = cdwscan;
            cdwscan = cdwscann;
            cdwscann = wscand;
            if (yl < h-1)
              filter(cdwfield, cdwscann, yl + 1);
            }
          else
            filter(cdwfield, cdwscan, yl);
          }
        }
      else
        {
        cdscan = dscan;
        cdwscan = dwscan;
        if (PLISTEXIST(wflag))
          {
          cdwscanp = dwscanp;
          cdwscann = dwscann;
          }
        }

      if ((check=prefs.check[CHECK_FILTERED]))
        writecheck(check, cdscan, w);
      }

    trunflag = (yl==0 || yl==h-1)? OBJ_TRUNC:0;

    for (xl=0; xl<=w; xl++)
      {
      if (xl == w)
        cdnewsymbol = -BIG;
      else
        cdnewsymbol = cdscan[xl];

      newmarker = marker[xl];
      marker[xl] = 0;

      curpixinfo.flag = trunflag;
      if (varthreshflag)
        thresh = relthresh*sqrt((xl==w || yl==h)? 0.0:cdwscan[xl]);
      luflag = cdnewsymbol > thresh?1:0;

      if (luflag)
        {
        if (xl==0 || xl==w-1)
          curpixinfo.flag |= OBJ_TRUNC;
        pixt = pixel + (cn=freeinfo.firstpix);
        freeinfo.firstpix = PLIST(pixt, nextpix);

/*------- Running out of pixels, the largest object becomes a "victim" ------*/

        if (freeinfo.firstpix==freeinfo.lastpix)
          {
          sprintf(gstr, "%d,%d", xl+1, yl+1);
          warning("Pixel stack overflow at position ", gstr);
          maxpixnb = 0;
          for (i=0; i<=w; i++)
            if (store[i].pixnb>maxpixnb)
              if (marker[i]=='S' || (newmarker=='S' && i==xl))
                {
                flag = 0;
                if (i<xl)
                  for (j=0; j<=co; j++)
                    flag |= (start[j]==i);
                if (!flag)
                  maxpixnb = (victim = &store[i])->pixnb;
                }
          for (j=1; j<=co; j++)
            if (info[j].pixnb>maxpixnb)
              maxpixnb = (victim = &info[j])->pixnb;

          if (!maxpixnb)
            error(EXIT_FAILURE, "*Fatal Error*: something is badly bugged in ",
		"scanimage()!");
          if (maxpixnb <= 1)
            error(EXIT_FAILURE, "Pixel stack overflow in ", "scanimage()");
          freeinfo.firstpix = PLIST(pixel+victim->firstpix, nextpix);
          PLIST(pixel+victim->lastpix, nextpix) = freeinfo.lastpix;
          PLIST(pixel+(victim->lastpix=victim->firstpix), nextpix) = -1;
          victim->pixnb = 1;
          victim->flag |= OBJ_OVERFLOW;
          }

/*---------------------------------------------------------------------------*/
        curpixinfo.lastpix = curpixinfo.firstpix = cn;
        PLIST(pixt, nextpix) = -1;
        PLIST(pixt, x) = xl;
        PLIST(pixt, y) = yl;
        PLIST(pixt, value) = scan[xl];
        if (PLISTEXIST(dvalue))
          PLISTPIX(pixt, dvalue) = dscan[xl];
        if (PLISTEXIST(cdvalue))
          PLISTPIX(pixt, cdvalue) = cdnewsymbol;
        if (PLISTEXIST(flag))
          for (i=0; i<nffield; i++)
            PLISTFLAG(pixt, flag[i]) = pfscan[i][xl];
/*--------------------- Detect pixels with a low weight ---------------------*/
        if (PLISTEXIST(wflag) && wscan)
          {
	  PLISTFLAG(pixt, wflag) = 0;
          if (wscan[xl] >= wthresh)
            PLISTFLAG(pixt, wflag) |= OBJ_LOWWEIGHT;
          if (cdwscan[xl] >= cdwthresh)
            PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;

          if (yl>0)
            {
            if (cdwscanp[xl] >= cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
            if (xl>0 && cdwscanp[xl-1]>=cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
            if (xl<w-1 && cdwscanp[xl+1]>=cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
            }
          if (xl>0 && cdwscan[xl-1]>=cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
          if (xl<w-1 && cdwscan[xl+1]>=cdwthresh)
            PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
          if (yl<h-1)
            {
            if (cdwscann[xl] >= cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
            if (xl>0 && cdwscann[xl-1]>=cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
            if (xl<w-1 && cdwscann[xl+1]>=cdwthresh)
              PLISTFLAG(pixt, wflag) |= OBJ_LOWDWEIGHT;
            }
          }
        if (PLISTEXIST(dthresh))
          PLISTPIX(pixt, dthresh) = thresh;
        if (PLISTEXIST(var))
          PLISTPIX(pixt, var) = wscan[xl];

        if (cs != OBJECT)
/*------------------------------- Start Segment -----------------------------*/

          {
          cs = OBJECT;
          if (ps == OBJECT)
            {
            if (start[co] == UNKNOWN)
              {
              marker[xl] = 'S';
              start[co] = xl;
              }
            else
              marker[xl] = 's';
            }
          else
            {
            psstack[pstop++] = ps;
            marker[xl] = 'S';
            start[++co] = xl;
            ps = COMPLETE;
            info[co] = initinfo;
            }
          }

/*---------------------------------------------------------------------------*/
        }

      if (newmarker)

/*---------------------------- Process New Marker ---------------------------*/

        {
        if (newmarker == 'S')
          {
          psstack[pstop++] = ps;
          if (cs == NONOBJECT)
            {
            psstack[pstop++] = COMPLETE;
            info[++co] = store[xl];
            start[co] = UNKNOWN;
            }
          else
            update (&info[co],&store[xl], pixel);
          ps = OBJECT;
          }
        else if (newmarker == 's')
          {
          if ((cs == OBJECT) && (ps == COMPLETE))
            {
            pstop--;
            xl2 = start[co];
            update (&info[co-1],&info[co], pixel);
            if (start[--co] == UNKNOWN)
              start[co] = xl2;
            else
              marker[xl2] = 's';
            }
          ps = OBJECT;
          }
        else if (newmarker == 'f')
          ps = INCOMPLETE;
        else if (newmarker == 'F')
          {
          ps = psstack[--pstop];
          if ((cs == NONOBJECT) && (ps == COMPLETE))
            {
            if (start[co] == UNKNOWN)
              {
              if ((int)info[co].pixnb >= prefs.ext_minarea)
                {
                sortit(field, dfield, wfield, cdwfield, &info[co], &objlist,
		       cdwscan, wscan);
                }
/* ------------------------------------ free the chain-list */

              PLIST(pixel+info[co].lastpix, nextpix) = freeinfo.firstpix;
              freeinfo.firstpix = info[co].firstpix;
              }
            else
              {
              marker[end[co]] = 'F';
              store[start[co]] = info[co];
              }
            co--;
            ps = psstack[--pstop];
            }
          }
        }
/*---------------------------------------------------------------------------*/

      if (luflag)
        update (&info[co],&curpixinfo, pixel);
      else
        {
        if (cs == OBJECT)
/*-------------------------------- End Segment ------------------------------*/
          {
          cs = NONOBJECT;
          if (ps != COMPLETE)
            {
            marker[xl] = 'f';
            end[co] = xl;
            }
          else
            {
            ps = psstack[--pstop];
            marker[xl] = 'F';
            store[start[co]] = info[co];
            co--;
            }
          }
        }

      if (prefs.blank_flag && xl<w)
        {
        if (prefs.filter_flag)
	  *(bpt++) = (luflag)?1:0;
        else if (luflag)
          dscan[xl] = -BIG;
        if (dfield && luflag)
          scan[xl] = -BIG;
        }
/*--------------------- End of the loop over the x's -----------------------*/
      }

/* Detected pixel removal at the end of each line */
    if (prefs.blank_flag && yl<h)
      {
      if (prefs.filter_flag)
        {
        bpt = bpt0 = blankpad + w*((yl+1)%blankh);
        if (cfield->yblank >= 0)
          {
          scant = &PIX(cfield, 0, cfield->yblank);
          for (i=w; i--; scant++)
            if (*(bpt++))
              *scant = -BIG;
          if (dfield)
            {
            bpt = bpt0;
            scant = &PIX(field, 0, cfield->yblank);
            for (i=w; i--; scant++)
              if (*(bpt++))
                *scant = -BIG;
            }
          bpt = bpt0;
          }
        }
      cfield->yblank++;
      if (dfield)
        field->yblank = cfield->yblank;
      }

/*-- Prepare markers for the next line */
    yl++;
    field->stripy = (field->y=yl)%field->stripheight;
    if (dfield)
      dfield->stripy = (dfield->y=yl)%dfield->stripheight;
    if (nffield)
      for (i=0; i<nffield; i++)
        {
        ffield = pffield[i];
        ffield->stripy = (ffield->y=yl)%ffield->stripheight;
        }
    if (wfield)
      wfield->stripy = (wfield->y=yl)%wfield->stripheight;
    if (dwfield)
      dwfield->stripy = (dwfield->y=yl)%dwfield->stripheight;

/*-- Remove objects close to the ymin limit if ymin is ready to increase */
    if (cfield->stripy==cfield->stripysclim)
      {
      cleanobj = cleanobjlist->obj+cleanobjlist->nobj-1;
      ontotal = 0;
      for (i=cleanobjlist->nobj; i--; cleanobj--)
        {
        if (cleanobj->ycmin <= cfield->ymin)
          {
/*-------- Warn if there is a possibility for any aperture to be truncated */
          if ((ymax=cleanobj->ycmax) > cfield->ymax)
            {
            sprintf(gstr, "Object at position %.0f,%.0f ",
		cleanobj->mx+1, cleanobj->my+1);
            QWARNING(gstr, "may have some apertures truncated:\n"
		"          You might want to increase MEMORY_BUFSIZE");
            }
          else if (ymax>cfield->yblank && prefs.blank_flag)
            {
            sprintf(gstr, "Object at position %.0f,%.0f ",
		cleanobj->mx+1, cleanobj->my+1);
            QWARNING(gstr, "may have some unBLANKed neighbours:\n"
		"          You might want to increase MEMORY_PIXSTACK");
            }
          if ((prefs.prof_flag && !(thecat.ntotal%10)
		&& thecat.ntotal != ontotal)
		|| !(thecat.ntotal%400))
            NPRINTF(OUTPUT, "\33[1M> Line:%5d  "
		"Objects: %8d detected / %8d sextracted\n\33[1A",
		yl>h? h:yl, thecat.ndetect, thecat.ntotal);
          ontotal = thecat.ntotal;
          endobject(field, dfield, wfield, cdwfield, i, cleanobjlist);
          subcleanobj(i);
          cleanobj = cleanobjlist->obj+i;	/* realloc in subcleanobj() */
          }
        }
      }

    if ((prefs.prof_flag && !(thecat.ntotal%10)) || !(yl%25))
      NPRINTF(OUTPUT, "\33[1M> Line:%5d  "
		"Objects: %8d detected / %8d sextracted\n\33[1A",
	yl>h?h:yl, thecat.ndetect, thecat.ntotal);
/*--------------------- End of the loop over the y's -----------------------*/
    }

/* Removal or the remaining pixels */
  if (prefs.blank_flag && prefs.filter_flag && (cfield->yblank >= 0))
    for (j=blankh-1; j--; yl++)
      {
      bpt = bpt0 = blankpad + w*(yl%blankh);
      scant = &PIX(cfield, 0, cfield->yblank);
      for (i=w; i--; scant++)
        if (*(bpt++))
          *scant = -BIG;
      if (dfield)
        {
        bpt = bpt0;
        scant = &PIX(field, 0, cfield->yblank);
        for (i=w; i--; scant++)
          if (*(bpt++))
            *scant = -BIG;
        }
      cfield->yblank++;
      if (dfield)
        field->yblank = cfield->yblank;
      }

/* Now that all "detected" pixels have been removed, analyse detections */
  ontotal = 0;
  for (j=cleanobjlist->nobj; j--;)
    {
    if ((prefs.prof_flag && !(thecat.ntotal%10) && thecat.ntotal != ontotal)
		|| !(thecat.ntotal%400))
      NPRINTF(OUTPUT, "\33[1M> Line:%5d  "
		"Objects: %8d detected / %8d sextracted\n\33[1A",
	h, thecat.ndetect, thecat.ntotal);
    ontotal = thecat.ntotal;
    endobject(field, dfield, wfield, cdwfield, 0, cleanobjlist);
    subcleanobj(0);
    }

  endclean();

/*Free memory */
  if (prefs.filter_flag && cdwfield && PLISTEXIST(wflag))
    free(cdwscanp);
  freeparcelout();
  free(pixel); pixel = NULL;
  lutzfree();
  free(info); info = NULL;
  free(store); store = NULL;
  free(marker); marker = NULL;
  free(dumscan); dumscan = NULL;
  free(psstack); psstack = NULL;
  free(start); start = NULL;
  free(end); end = NULL;
  if (prefs.blank_flag && prefs.filter_flag)
    free(blankpad); blankpad = NULL;

  return;
  }
Пример #25
0
/** interpolateBiCub: bi-cubic interpolation function using 4x4 pixel, see interpolate */
void _FLT(interpolateBiCub)(unsigned char *rv, float x, float y,
                            unsigned char* img, int width, int height, unsigned char def)
{
    // do a simple linear interpolation at the border
    if (x < 1 || x > width - 2 || y < 1 || y > height - 2) {
        _FLT(interpolateBiLinBorder)(rv, x,y,img,width,height,def);
    } else {
        int x_f = myfloor(x);
        int y_f = myfloor(y);
        float tx = x-x_f;
        short v1 = _FLT(bicub_kernel)(tx,
                                      PIX(img, x_f-1, y_f-1, width, height),
                                      PIX(img, x_f,   y_f-1, width, height),
                                      PIX(img, x_f+1, y_f-1, width, height),
                                      PIX(img, x_f+2, y_f-1, width, height));
        short v2 = _FLT(bicub_kernel)(tx,
                                      PIX(img, x_f-1, y_f, width, height),
                                      PIX(img, x_f,   y_f, width, height),
                                      PIX(img, x_f+1, y_f, width, height),
                                      PIX(img, x_f+2, y_f, width, height));
        short v3 = _FLT(bicub_kernel)(tx,
                                      PIX(img, x_f-1, y_f+1, width, height),
                                      PIX(img, x_f,   y_f+1, width, height),
                                      PIX(img, x_f+1, y_f+1, width, height),
                                      PIX(img, x_f+2, y_f+1, width, height));
        short v4 = _FLT(bicub_kernel)(tx,
                                      PIX(img, x_f-1, y_f+2, width, height),
                                      PIX(img, x_f,   y_f+2, width, height),
                                      PIX(img, x_f+1, y_f+2, width, height),
                                      PIX(img, x_f+2, y_f+2, width, height));
        *rv = (unsigned char)_FLT(bicub_kernel)(y-y_f, v1, v2, v3, v4);
    }
}
Пример #26
0
static void
edge (GimpDrawable *drawable)
{
  GimpPixelRgn      src_rgn, dest_rgn;
  gpointer          pr;
  GimpPixelFetcher *pft;
  guchar           *srcrow, *src;
  guchar           *destrow, *dest;
  guchar            pix00[4], pix01[4], pix02[4];
  guchar            pix10[4], pix11[4], pix12[4];
  guchar            pix20[4], pix21[4], pix22[4];
  glong             width, height;
  gint              alpha;
  gboolean          has_alpha;
  gint              chan;
  gint              x, y;
  gint              x1, y1, x2, y2;
  gint              maxval;
  gint              cur_progress;
  gint              max_progress;
  gdouble           per_progress;

  if (evals.amount < 1.0)
    evals.amount = 1.0;

  pft = gimp_pixel_fetcher_new (drawable, FALSE);
  gimp_pixel_fetcher_set_edge_mode (pft, evals.wrapmode);

  gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);

  width     = gimp_drawable_width (drawable->drawable_id);
  height    = gimp_drawable_height (drawable->drawable_id);
  alpha     = gimp_drawable_bpp (drawable->drawable_id);
  has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
  if (has_alpha)
    alpha--;

  maxval = 255;

  cur_progress = 0;
  per_progress = 0.0;
  max_progress = (x2 - x1) * (y2 - y1) / 100;

  gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, x2-x1, y2-y1, FALSE, FALSE);
  gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2-x1, y2-y1, TRUE, TRUE);

  for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
       pr != NULL;
       pr = gimp_pixel_rgns_process (pr))
    {
      srcrow  = src_rgn.data;
      destrow = dest_rgn.data;

      for (y = dest_rgn.y;
           y < (dest_rgn.y + dest_rgn.h);
           y++, srcrow += src_rgn.rowstride, destrow += dest_rgn.rowstride)
        {
          src  = srcrow;
          dest = destrow;

          for (x = dest_rgn.x;
               x < (dest_rgn.x + dest_rgn.w);
               x++,  src += src_rgn.bpp, dest += dest_rgn.bpp)
            {
              if (dest_rgn.x < x &&  x < dest_rgn.x + dest_rgn.w - 2 &&
                  dest_rgn.y < y &&  y < dest_rgn.y + dest_rgn.h - 2)
                {
                  /*
                   * 3x3 kernel is inside of the tile -- do fast
                   * version
                   */
                  for (chan = 0; chan < alpha; chan++)
                    {
                      /* get the 3x3 kernel into a guchar array,
                       * and send it to edge_detect */
                      guchar kernel[9];
                      gint   i,j;

#define PIX(X,Y)  src[ (Y-1)*(int)src_rgn.rowstride + (X-1)*(int)src_rgn.bpp + chan ]
                      /* make convolution */
                      for(i = 0; i < 3; i++)
                        for(j = 0; j < 3; j++)
                          kernel[3*i + j] = PIX(i,j);

#undef  PIX

                      dest[chan] = edge_detect (kernel);
                    }
                }
              else
                {
                  /*
                   * The kernel is not inside of the tile -- do slow
                   * version
                   */

                  gimp_pixel_fetcher_get_pixel (pft, x-1, y-1, pix00);
                  gimp_pixel_fetcher_get_pixel (pft, x  , y-1, pix10);
                  gimp_pixel_fetcher_get_pixel (pft, x+1, y-1, pix20);
                  gimp_pixel_fetcher_get_pixel (pft, x-1, y  , pix01);
                  gimp_pixel_fetcher_get_pixel (pft, x  , y  , pix11);
                  gimp_pixel_fetcher_get_pixel (pft, x+1, y  , pix21);
                  gimp_pixel_fetcher_get_pixel (pft, x-1, y+1, pix02);
                  gimp_pixel_fetcher_get_pixel (pft, x  , y+1, pix12);
                  gimp_pixel_fetcher_get_pixel (pft, x+1, y+1, pix22);

                  for (chan = 0; chan < alpha; chan++)
                    {
                      guchar kernel[9];

                      kernel[0] = pix00[chan];
                      kernel[1] = pix01[chan];
                      kernel[2] = pix02[chan];
                      kernel[3] = pix10[chan];
                      kernel[4] = pix11[chan];
                      kernel[5] = pix12[chan];
                      kernel[6] = pix20[chan];
                      kernel[7] = pix21[chan];
                      kernel[8] = pix22[chan];

                      dest[chan] = edge_detect (kernel);
                    }
                }
              if (has_alpha)
                dest[alpha] = src[alpha];
            }
        }
      cur_progress += dest_rgn.w * dest_rgn.h;

      if (cur_progress > max_progress)
        {
          cur_progress = cur_progress - max_progress;
          per_progress = per_progress + 0.01;
          gimp_progress_update (per_progress);
        }
    }

  gimp_progress_update (1.0);

  gimp_pixel_fetcher_destroy (pft);

  gimp_drawable_flush (drawable);
  gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
  gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
void
detect_edges(Image *img, float sigma, float threshold, \
             unsigned char *edge_pix, PList *edge_pts)
{
	int x, y;
	int w = img->w;
	int h = img->h;

	// convert image to grayscale
	float **gray = array_create(w, h);
	convert_grayscale(img, gray);

	// blur grayscale image
	float **gray2 = array_create(w, h);
	gaussian_blur(gray, gray2, w, h, sigma);

	// compute gradient of blurred image
	float **g_mag = array_create(w, h);
	float **g_ang = array_create(w, h);
	compute_gradient(gray2, w, h, g_mag, g_ang);

	// mark edge pixels
	#define PIX(y,x) edge_pix[(y)*w+(x)]
#pragma omp parallel 
{
#pragma omp for private(x) nowait
	for (y = 0; y < h; y++)
	for (x = 0; x < w; x++)
	{
		PIX(y,x) = is_edge(g_mag,g_ang,threshold,x,y,w,h) ? 255 : 0;
	}

	// connect horizontal edges
#pragma omp for private(x) nowait
	for (y = 0; y < h  ; y++)
	for (x = 1; x < w-1; x++)
	{
		if (!PIX(y,x) && PIX(y,x+1) && PIX(y,x-1))
			PIX(y,x) = 255;
	}

	// connect vertical edges
#pragma omp for private(y) nowait
	for (x = 0; x < w  ; x++)
	for (y = 1; y < h-1; y++)
	{
		if (!PIX(y,x) && PIX(y+1,x) && PIX(y-1,x))
			PIX(y,x) = 255;
	}
#pragma omp for private(x) 
	// connect diagonal edges
	for (y = 1; y < h-1; y++)
	for (x = 1; x < w-1; x++)
	{
		if (!PIX(y,x) && PIX(y-1,x-1) && PIX(y+1,x+1))
			PIX(y,x) = 255;
		if (!PIX(y,x) && PIX(y-1,x+1) && PIX(y+1,x-1))
			PIX(y,x) = 255;
	}
}
	// add edge points to list
	if (edge_pts)
	{
		for (y = 0; y < h; y++)
		for (x = 0; x < w; x++)
		{
			if (PIX(y,x)) PList_push(edge_pts, x, y);
		}
	}

	// cleanup
	array_free(g_mag, h);
	array_free(g_ang, h);
	array_free(gray2, h);
	array_free(gray, h);
}
Пример #28
0
static int GetPSF (char *name, Hdr *phdr, double xsize, double ysize,
                   ScatterFunctions *scf,
                   Image *psf1, Image *psf2, Image *psf3) {

/*
char *name;             i: name of TELTAB reference file
Hdr *phdr               i: primary header
double xsize, ysize;    i: aperture size in arcsec
ScatterFunctions *scf;  o: data structure with scattering functions
Image *psf1,2,3;        o: PSF images, previously initialized
*/
        IRAFPointer tp;
        IRAFPointer cp_refwave, cp_pscale, cp_psfdim, cp_telepsf;
        int row, nrows, psfdim;
        double rw, psfscale;
        Image ospsf;
        Image imtemp, psf;
        char keyword[STIS_CBUF];
        double xplate, yplate;
        double sbox, lbox;
        double rstart, rstop;
        double frac1, frac2;
        float fhold;
        double sum;
        int i, j, k, kk, ms, ml, ns, nl, s, l;
        int ns2, nl2, s1, s2, l1, l2;
        int istart, istop;
        int status;

        int Alloc1DImage (Image *, int);
        int Alloc2DImage (Image *, int, int);
        void InitImage (Image *);
        void FreeImage (Image *);

        /* Define plate scale. */

        if (streq_ic (scf->opt_elem, "E140M"))
            xplate = 0.036;
        else if (streq_ic (scf->opt_elem, "E140H"))
            xplate = 0.0466;
        else if (streq_ic (scf->opt_elem, "E230M"))
            xplate = 0.033;
        else if (streq_ic (scf->opt_elem, "E230H"))
            xplate = 0.0466;
        else {
            printf ("Non supported grating.\n");
            return (ERROR_RETURN);
        }
        yplate = 0.029;

        /* Truncate the aperture size if it extends beyond the borders
           of an image.
        */

        /* See if uniformly illuminated aperture was used. */

        if ((status = Get_KeyS (phdr, "SCLAMP", 0, "", keyword, STIS_CBUF)))
            return (status);
        if (!streq_ic (keyword, "NONE")) {
            ml = (int)floor (ysize / yplate);
            if (ml % 2) {
                status  = Alloc1DImage (psf1, ml+1);
                status |= Alloc1DImage (psf2, ml+1);
                status |= Alloc1DImage (psf3, ml+1);
                if (status)
                    return (status);
                for (i = 1; i < ml; i++) {
                    psf1->pix[i] = 1.0 / ml;
                    psf2->pix[i] = 1.0 / ml;
                    psf3->pix[i] = 1.0 / ml;
                }
                psf1->pix[0]  = 0.5 / ml;
                psf1->pix[ml] = 0.5 / ml;
                psf2->pix[0]  = 0.5 / ml;
                psf2->pix[ml] = 0.5 / ml;
                psf3->pix[0]  = 0.5 / ml;
                psf3->pix[ml] = 0.5 / ml;
            } else {
                status  = Alloc1DImage (psf1, ml);
                status |= Alloc1DImage (psf2, ml);
                status |= Alloc1DImage (psf3, ml);
                if (status)
                    return (status);
                for (i = 0; i < ml; i++) {
                    psf1->pix[i] = 1.0 / ml;
                    psf2->pix[i] = 1.0 / ml;
                    psf3->pix[i] = 1.0 / ml;
                }
            }
            return (STIS_OK);
        }

        /* Scan reference file and process each PSF. */

        tp = c_tbtopn (name, IRAF_READ_ONLY, 0);
        if (c_iraferr()) {
            printf ("ERROR    TELTAB `%s' not found\n", name);
            return (OPEN_FAILED);
        }
        nrows = c_tbpsta (tp, TBL_NROWS);
        c_tbcfnd1 (tp, "PSFWAVE", &cp_refwave);
        c_tbcfnd1 (tp, "PSCALE",  &cp_pscale);
        c_tbcfnd1 (tp, "PSFDIM",  &cp_psfdim);
        c_tbcfnd1 (tp, "TELEPSF", &cp_telepsf);
        if (cp_refwave == 0 || cp_psfdim  == 0 ||
            cp_pscale  == 0 || cp_telepsf == 0) {
            printf( "ERROR    Column not found in TELTAB\n");
            c_tbtclo (tp);
            return (COLUMN_NOT_FOUND);
        }

        kk = 0;
        for (row = 1; row <= nrows ; row++) {

            c_tbegtd (tp, cp_refwave, row, &rw);
            if (c_iraferr())
                return (TABLE_ERROR);

            /* Matching reference wavelenghts. */

            if (rw == scf->psfw[kk]) {

                /* Read PSF image and associated data. */

                c_tbegtd (tp, cp_pscale, row, &psfscale);
                c_tbegti (tp, cp_psfdim, row, &psfdim);

                InitImage (&imtemp);
                if ((status = Alloc2DImage (&imtemp, psfdim, psfdim)))
                    return (status);
                i = c_tbagtr (tp, cp_telepsf, row, imtemp.pix, 1,
                              imtemp.npix);
                if (c_iraferr())
                    return (TABLE_ERROR);

                /* Find peak. */

                ns = imtemp.nx;
                nl = imtemp.ny;
                fhold = -FLT_MAX;
                for (i = 0; i < ns; i++) {
                    for (j = 0; j < nl; j++) {
                        if (PIX (imtemp, i, j) > fhold) {
                            s = i;
                            l = j;
                            fhold = PIX (imtemp, i, j);
                        }
                    }
                }

                /* Determine portion of PSF that made it through aperture. */

                ns2 = ((int)NINT (xsize / psfscale)) / 2;
                nl2 = ((int)NINT (ysize / psfscale)) / 2;
                s1  = ((s - ns2) >= 0) ? (s - ns2) : 0;
                s2  = ((s + ns2) <= (ns - 1)) ? (s + ns2) : (ns - 1);
                l1  = ((l - nl2) >= 0) ? (l - nl2) : 0;
                l2  = ((l + nl2) <= (nl - 1)) ? (l + nl2) : (nl - 1);

                /* Extract sub-image. */

                InitImage (&ospsf);
                if ((status = Alloc2DImage (&ospsf, s2 - s1 + 1, l2 - l1 + 1)))
                    return (status);
                k = 0;
                /* location of braces looks like a typo, but harmless */
                for (j = l1; j <= l2; j++)
                    for (i = s1; i <= s2; i++) {
                        ospsf.pix[k++] = PIX (imtemp, i, j);
                }
                FreeImage (&imtemp);
                ns = ospsf.nx;
                nl = ospsf.ny;

                /* # of STIS pixels (ms*ml) illuminated by aperture. */

                /* modified on 2013 Nov 13 by PEH
                   xplate / psfscale and yplate / psfscale are the factors
                   by which the PSF in the _tel.fits file are oversampled.
                */
                ms = (NINT (ns / (xplate / psfscale))) / 2;
                ml = (NINT (nl / (yplate / psfscale))) / 2;
                ms = 2 * ms + 1;
                ml = 2 * ml + 1;

                /* Bin oversampled PSF to STIS pixel scale. */

                /* Bin columns. */

                if ((status = Alloc2DImage (&imtemp, ms, nl)))
                    return (status);
                sbox = ns / (double)ms;
                for (i = 0; i < ms; i++) {
                    rstart = i     * sbox;
                    rstop  = (i+1) * sbox;
                    istart = (int) floor (rstart);
                    istop  = (int) floor (rstop);
                    istop = (istop < ns) ? istop : ns-1;
                    frac1 = rstart - istart;
                    frac2 = 1.0 - (rstop - istop);
                    for (j = 0; j < nl; j++) {
                        for (k = istart+1; k < istop;
                            PIX (imtemp, i, j) += PIX (ospsf, k++, j));
                        PIX (imtemp, i, j) += PIX (ospsf, istart, j) *
                                              (1.0 - frac1);
                        PIX (imtemp, i, j) += PIX (ospsf, istop,  j) *
                                              (1.0 - frac2);
                    }
                }
                FreeImage (&ospsf);

                /* Bin rows. */

                InitImage (&psf);
                if ((status = Alloc2DImage (&psf, ms, ml)))
                    return (status);
                lbox = nl / (double)ml;
                for (j = 0; j < ml; j++) {
                    rstart = j     * lbox;
                    rstop  = (j+1) * lbox;
                    istart = (int) floor (rstart);
                    istop  = (int) floor (rstop);
                    istop = (istop < nl) ? istop : nl-1;
                    frac1 = rstart - istart;
                    frac2 = 1.0 - (rstop - istop);
                    for (i = 0; i < ms; i++) {
                        for (k = istart+1; k < istop;
                             PIX (psf, i, j) += PIX (imtemp, i, k++));
                        PIX (psf, i, j) += PIX (imtemp, i, istart) *
                                            (1.0 - frac1);
                        PIX (psf, i, j) += PIX (imtemp, i, istop) *
                                            (1.0 - frac2);
                    }
                }
                FreeImage (&imtemp);

                /* Normalize PSF to unit area. */

                sum = 0.0;
                for (i = 0; i < psf.npix; sum += psf.pix[i++]);
                for (i = 0; i < psf.npix; psf.pix[i++] /= sum);

                /* This awful code is a consequence of the
                   change in reference file format that took place
                   after the original code was completed.
                */
                switch (kk) {
                case 0:
                    if ((status = Alloc2DImage (psf1, psf.nx, psf.ny)))
                        return (status);
                    for (i= 0 ; i < psf1->npix; i++)
                        psf1->pix[i] = psf.pix[i];
                    break;
                case 1:
                    if ((status = Alloc2DImage (psf2, psf.nx, psf.ny)))
                        return (status);
                    for (i= 0 ; i < psf2->npix; i++)
                        psf2->pix[i] = psf.pix[i];
                    break;
                case 2:
                    if ((status = Alloc2DImage (psf3, psf.nx, psf.ny)))
                        return (status);
                    for (i= 0 ; i < psf3->npix; i++)
                        psf3->pix[i] = psf.pix[i];
                    break;
                default:
                    break;
                }

                FreeImage (&psf);
                kk++;
            }
        }

        if (kk == 0) {
            printf ("ERROR    No matching rows in TELTAB `%s'\n", name);
            return (TABLE_ERROR);
        }

        c_tbtclo (tp);
        return (STIS_OK);
}