示例#1
0
 /*
  Median filter that only modifies a pixel when it significantly differs from the median of its 8-connected neighborhood that is weighted by the variance
  
  @param img:        input image
  @param imgPara:    struct with parameters
  @param original:   current height map
  @param filterRadius:     radius to define the 8-connected neighborhood
  @param threshold:  threshold to identify pixels that need to be modified
  */
 Array * LocalMedianFilter_InclVar(RasterizedImage & img, ParaSet & imgPara, Array * original, int filterRadius, double threshold){
   
   uint32 *orig    = AUINT32(original);
   Array  *median = Make_Array_With_Shape(PLAIN_KIND, UINT32_TYPE, Coord2(original->dims[1], original->dims[0]));
   uint32 *med    = AUINT32(median);
   
   Use_Extend_Boundary();
   
   Frame * f = Make_Frame(original,Coord2(2*filterRadius+1,2*filterRadius+1),Coord2(filterRadius, filterRadius));
   
   // Frame to compute the variance in intensity of the current grid element
   Frame * varF = Make_Frame(img.GetImage(),Coord3(1, imgPara.radius,imgPara.radius),Coord3(0, 0, 0));
   Histogram * varH = Make_Histogram(UVAL,256,ValU(1),ValU(0));
   
   uint32 * data;
   
   Place_Frame(f,0);
   Place_Frame(varF, 0);
   
   
   for (Dimn_Type y = 0; y <= img.GetHeight()-imgPara.radius; y += imgPara.radius){
     for (Dimn_Type x = 0; x <= img.GetWidth()-imgPara.radius; x += imgPara.radius){
       
       Indx_Type pHM = (y/imgPara.radius) * original->dims[0] + (x/imgPara.radius);
       Place_Frame(f, pHM);
       data = (uint32 *) Frame_Values(f);
       std::vector<double> depths;
       double sum = 0;
       double n = 0;
       
       for (int i = 0; i < AForm_Size(f); i++) {
         Indx_Type p = Coord2IdxA(img.GetImage(), Coord3(data[i],y, x));
         Place_Frame(varF, p);
         Histagain_Array(varH,varF,0);
         
         sum += Histogram_Variance(varH) * data[i];
         n += Histogram_Variance(varH);
         for (int j=0; j< floor(Histogram_Variance(varH)/10); j++) {   // weight the current height with the variance
           depths.push_back(data[i]);
         }
       }
       double weightedMedian = VectorMedian(depths);
       
       if (abs(orig[pHM] - weightedMedian) > threshold ) {
         med[pHM] = floor(weightedMedian);
       } else {
         med[pHM] = orig[pHM];
       }
       
     }
   }
   
   Kill_Histogram(varH);
   Kill_Frame(varF);
   Kill_Frame(f);
   
   return median;
 }
示例#2
0
  void RasterizedImage::SetGrid(const int radius){
    gridX_ = ceil ((double)realWidth_/(double)radius);
    gridY_ = ceil ((double)realHeight_/(double)radius);
    Use_Extend_Boundary();
    Pad_Array_Inplace(*image_, Coord3(0, 0, 0), Coord3(depth_, gridY_*radius, gridX_*radius));

    SetWidth((*image_)->dims[0]);
    SetHeight((*image_)->dims[1]);
  }
示例#3
0
 //default world:
// width = 1000, length = 1000, object at (500, 500)
World::World()
{
	this->object = Coord3(500, 500, 0);
	this->width = 1000;
	this->length = 1000;
	this->x_inc = 50;
	this->y_inc = 100;
}
示例#4
0
World::World(double obj_x, double obj_y, double obj_z, double width, double length)
{
	this->object = Coord3(obj_x, obj_y, obj_z);
	this->width = width;
	this->length = length;
	this->x_inc = 50;
	this->y_inc = 100;

}
示例#5
0
int Read_All_Channels(string name, int maxchans)
{ Tiff *tif;
  int   depth, height, width, chans;
  int   i;

  if(strcmp(getSuffix(name), "tif")==0 || strcmp(getSuffix(name), "lsm")==0) {

    tif = Open_Tiff(name,"r");
    if (tif == NULL)
      { fprintf(stderr,"Cannot open file %s for reading\n",name);
	exit (1);
      }

    Get_IFD_Shape(tif,&width,&height,&chans);

    printf("width=%d height=%d chans=%d\n", width, height, chans);

    if (chans < 2)
      { fprintf(stderr,"LSM %s does not at least 2 channels\n",name);
	exit (1);
      }

    depth = 0;
    while ( ! Tiff_EOF(tif))
      { int w, h, c;
	Get_IFD_Shape(tif,&w,&h,&c);
	if (w == width && h == height && c == chans)
	  { for (i = 0; i < chans; i++)
	      if (Get_IFD_Channel_Type(tif,i) != UINT16_TYPE)
		{ fprintf(stderr,"Channel %d of %s is not 16-bit)\n",i,name);
		  exit (1);
		}
	    depth += 1;
	  }
	Advance_Tiff(tif);
      }

    Rewind_Tiff(tif);
    
    if (NumChans + chans > maxchans)
      { maxchans = 1.2*(NumChans+chans) + 20;
	Images   = (Array **) Guarded_Realloc(Images,sizeof(Array *)*maxchans,Program_Name());
      }
     
    for (i = NumChans; i < NumChans + chans; i++)
      Images[i] = Make_Array_With_Shape(PLAIN_KIND,UINT16_TYPE,Coord3(depth,height,width));

    depth = 0;
    while ( ! Tiff_EOF(tif))
      { int w, h, c;
	Get_IFD_Shape(tif,&w,&h,&c);
	if (w == width && h == height && c == chans)
	  { for (i = 0; i < chans; i++)
	      { Array_Bundle plane = *(Images[NumChans+i]);
		Get_IFD_Channel(tif,i,Get_Array_Plane(&plane,depth));
	      }
	    depth += 1;
	  }
	Advance_Tiff(tif);
      }

    Close_Tiff(tif);

    NumChans += chans;
    return (maxchans);

  } else if (strcmp(getSuffix(name), "raw")==0 || strcmp(getSuffix(name), "v3draw")==0) {

    unsigned char* img;
    long* sz;
    img=0;
    sz=0;

    int rawLoadResult=loadRaw2Stack(name, &img, &sz, 2);
    if (rawLoadResult!=0) {
      fprintf(stderr, "Load of raw file failed\n");
      exit(1);
    }
    if (sizeof(unsigned short)!=2) {
      fprintf(stderr, "Read_All_Channels() making false assumption that unsigned short is size=2\n");
      exit(1);
    }
    unsigned short* rawp=(unsigned short*)img;

    width=sz[0];
    height=sz[1];
    depth=sz[2];
    chans=sz[3];

    printf("width=%d height=%d depth=%d chans=%d\n", width, height, depth, chans);

    if (chans < 2)
      { fprintf(stderr,"File %s does not contain at least 2 channels\n",name);
	exit (1);
      }

    if (NumChans + chans > maxchans)
      { maxchans = 1.2*(NumChans+chans) + 20;
	Images   = (Array **) Guarded_Realloc(Images,sizeof(Array *)*maxchans,Program_Name());
      }
     
    for (i = NumChans; i < NumChans + chans; i++) {
      Images[i] = Make_Array_With_Shape(PLAIN_KIND,UINT16_TYPE,Coord3(depth,height,width));
      {
	int rx,ry,rz;
	uint16 *v;
	Indx_Type p;

	v = AUINT16(Images[i]);
	p = 0;
	long oc=(i-NumChans)*depth*height*width;
	for (rz=0;rz<depth;rz++) {
	  long oz = rz*height*width;
	  for (ry=0;ry<height;ry++) {
	    long oy = ry*width;
	    for (rx=0;rx<width;rx++) {
	      long offset=oc + oz + oy + rx;
	      unsigned short uv = *(rawp + offset);
	      v[p++] = uv;
	    }
	  }
	}
      }
    }

    NumChans += chans;
    return (maxchans);

  } else {
    fprintf(stderr, "Do not recognize file suffix %s\n", getSuffix(name));
    exit(1);
  }
}
示例#6
0
 /*
  Method that presents the image arr with a grid overlap
  
  @param image:   input image stack
  @param imgPara: input parameter
  @param name:    name of the output file
  @param arr:     image which should be plotted
  */
 void ShowArray(RasterizedImage & img, ParaSet & imgPara, char * name, Array * arr)
 {
   Dimn_Type x, y, z;
   Array    * a, * b;
 
   if (imgPara.grid == false){
     Write_Image((char *) name, arr, DONT_PRESS);
     return;
   }
 
   // Conversion of the image arr into an RGB-Kind image
   if (arr->type != UINT8_TYPE){
     b = Copy_Array(arr);
     Scale_Array_To_Range(b,ValU(0),ValU(255));
     Convert_Array_Inplace(b,b->kind,UINT8_TYPE,8,0);
   } else {
     b = arr;
   }
 
   if (b->kind != RGB_KIND){
     if (b == arr){
       a = Convert_Array(b,RGB_KIND,b->type,b->scale,0);
     } else {
       a = Convert_Array_Inplace(b,RGB_KIND,b->type,b->scale,0);
     }
   } else {
     a = b;
   }
 
   // Plotting of the image grid
   if (a->ndims == 4)
     for (z = 0; z < img.GetDepth(); z++){
       for (y = 0; y < img.GetGridY(); y++) {
         if (y % 50 == 0 && y != 0){
           Draw_Line(a,&YELLOW,Coord3(z,y*imgPara.radius,0),Coord3(z,y*imgPara.radius,img.GetGridX()*imgPara.radius-1));
         } else if (y % 10 == 0 && y != 0){
           Draw_Line(a,&PURPLE,Coord3(z,y*imgPara.radius,0),Coord3(z,y*imgPara.radius,img.GetGridX()*imgPara.radius-1));
         } else {
           Draw_Line(a,&CYAN,Coord3(z,y*imgPara.radius,0),Coord3(z,y*imgPara.radius,img.GetGridX()*imgPara.radius-1));
         }
         for (x = 0; x < img.GetGridX(); x++){
           if (x % 50 == 0 && x != 0){
             Draw_Line(a,&YELLOW,Coord3(z,0,x*imgPara.radius),Coord3(z,img.GetGridY()*imgPara.radius-1,x*imgPara.radius));
           } else if (x % 10 == 0 && x != 0){
             Draw_Line(a,&PURPLE,Coord3(z,0,x*imgPara.radius),Coord3(z,img.GetGridY()*imgPara.radius-1,x*imgPara.radius));
           } else {
             Draw_Line(a,&CYAN,Coord3(z,0,x*imgPara.radius),Coord3(z,img.GetGridY()*imgPara.radius-1,x*imgPara.radius));
           }
         }
       }
     }
   else{
     for (y = 0; y < img.GetGridY(); y++){
       if (y % 50 == 0 && y != 0){
         Draw_Line(a,&YELLOW,Coord2(y*imgPara.radius,0),Coord2(y*imgPara.radius,img.GetGridX()*imgPara.radius-1));
       } else if (y % 10 == 0 && y != 0){
         Draw_Line(a,&PURPLE,Coord2(y*imgPara.radius,0),Coord2(y*imgPara.radius,img.GetGridX()*imgPara.radius-1));
       } else{
         Draw_Line(a,&CYAN,Coord2(y*imgPara.radius,0),Coord2(y*imgPara.radius,img.GetGridX()*imgPara.radius-1));
       }
       for (x = 0; x < img.GetGridX(); x++){
         if (x % 50 == 0 && x != 0){
           Draw_Line(a,&YELLOW,Coord2(0,x*imgPara.radius),Coord2(img.GetGridY()*imgPara.radius-1,x*imgPara.radius));
         } else if (x % 10 == 0 && x != 0){
           Draw_Line(a,&PURPLE,Coord2(0,x*imgPara.radius),Coord2(img.GetGridY()*imgPara.radius-1,x*imgPara.radius));
         } else{
           Draw_Line(a,&CYAN,Coord2(0,x*imgPara.radius),Coord2(img.GetGridY()*imgPara.radius-1,x*imgPara.radius));
         }
       }
     }
   }
   
   Write_Image(name, a, DONT_PRESS);
   
   if (arr != a)
     Free_Array(a);
 }