const QPixmap ribi::FilterOperationerMainDialog::DoFilterOperation(
  const QPixmap& source,
  const boost::numeric::ublas::matrix<double>& filter)
{
  const std::vector<std::vector<int> > v {
    PixmapToVector(source)
  };

  const std::vector<std::vector<double> > w {
    MatrixToVector(filter)
  };

  const std::vector<std::vector<int> > x {
    DoFilterOperation(
      v, //y-x-ordered
      w //y-x-ordered
    )
  };

  const QImage image {
    VectorToImage(x)
  };

  QPixmap result { QPixmap::fromImage(image) };
  return result;
}
Пример #2
0
//---------------------------------------------------------------------------
void __fastcall TFormMain::ButtonDoClick(
      TObject *Sender)
{

  const std::vector<std::vector<int> > source_int = ImageToVector(ImageSource);
  const std::vector<std::vector<double> > source = Convert<int,double>(source_int);
  const std::vector<std::vector<double> > result_unscaled = DoFilterOperation(source,mFilter);
  const std::vector<std::vector<double> > result_scaled = Rescale(result_unscaled,0.0,255.9);
  const std::vector<std::vector<int> > result = Convert<double,int>(result_scaled);
  VectorToImage(result,ImageTarget);
  ImageTarget->Visible = true;
  ImageTarget->Refresh();
  ButtonSaveResult->Enabled = true;
  ++PageControl->ActivePageIndex;
}
Пример #3
0
Файл: it.c Проект: cran/PET
/***************************************************************
[NAME]
SaveIteration

[SYNOPSIS]
void SaveIteration(Vector *MyVector, 
                   int iteration, 
                   char *filename)

[DESCRIPTION] 

This function is used to save a series of images while iterating. The
function saves an image with the specified outputname + a number
indicating which iteration the picture represents.

[USAGE]
{\tt SaveIteration(TestVector, 123, "testImage");}

Saves the vector {\tt TestVector} as the image `{\tt testimage.123.pet}'.

[REVISION]
Dec. 94, JJJ
July 2006, Joern Schulz
***************************************************************/
void SaveIteration(Vector *MyVector, int iteration, char *filename)
{
  char outfilename[100];
  char itstr[10];
  Image *NewImage;

  strcpy(outfilename,filename);
  sprintf(itstr,".%d",iteration);  
  strcat(outfilename,itstr);

  NewImage=VectorToImage(MyVector,itINI.XSamples,itINI.YSamples);

  RenameImage(NewImage,outfilename);
  NewImage->DeltaX=itINI.DeltaX;
  NewImage->DeltaY=itINI.DeltaY;
  NewImage->Xmin=itINI.Xmin;
  NewImage->Ymin=itINI.Ymin;
  ScaleImage(NewImage);
  WritePET(NewImage);
  FreeImage(NewImage);
}
Пример #4
0
Файл: art.c Проект: cran/PET
/****************************************************************************
[NAME]
SLOW\_ART

[SYNOPSIS]
Image *SLOW_ART(Vector *xvector,
                Vector *bvector)

[DESCRIPTION]
This function will iterate towards a solution for the sparse system of 
equations \mb{b}=\mb{A x}, where \mb{b} is the sinogram (Radon domain)
and \mb{x} is the reconstructed image to be found. The function uses a 
slow version of ART (Algebraric Reconstruction Techniques) where the 
transformation matrix is calculated on the fly.

[USAGE]
{\tt Image=ART(TestMatrix, TestSinogram);}

Reconstructs the sinogram {\tt TestSinogram}, returns it as an image.

[REVISION]
Jan. 95, JJJ and PT
July 06, J.Schulz, Modification of ReadRefImage and the condition to
                   SaveIterions
****************************************************************************/
Image *SLOW_ART(Vector *xvector, Vector *bvector)
{
  int ARows,ACols,currentrow,currentiteration,TotalIterations,AntPrint,UseRefImage;
  float denom,lambda,brk;
  //refxdev=0.0;
  float *tempXv,*tempBv;
  char DiffFileName[200];
  FILE *DiffFile=NULL;
  Vector *refxvector=NULL,*AVector;
  Image *Recon,*RefImage=NULL;

  ARows=bvector->N;
  ACols=xvector->N;

  Print(_DNormal,"Using ART (slow) to solve %i equations with %i unknowns\n",
	ARows,ACols);

  UseRefImage=(strlen(itINI.RefFileName)!=0);
  if (UseRefImage!=0) {
    RefImage=ReadRefImage(itINI.RefFileName);
    refxvector=ImageToVector(RefImage);
    FreeImage(RefImage);
    //refxdev=DeviationVector(refxvector);
    strcpy(DiffFileName,itINI.RefFileName);
    strcat(DiffFileName,".dif");
    DiffFile=fopen(DiffFileName,"wt");
    Print(_DNormal,"Logging differences in `%s' \n", DiffFileName);
  }

  tempXv=xvector->value;
  tempBv=bvector->value;
  //srand((int)clock());
  lambda=itINI.Alpha/itINI.Beta;

  TotalIterations=itINI.Iterations*ARows;
  AntPrint=(int)(TotalIterations/93);

  InitArrays();

  for (currentiteration=0;currentiteration<TotalIterations;currentiteration++)
  { 
    if (currentiteration%ARows==0) lambda*=itINI.Beta;
    if (currentiteration%AntPrint==0)
      Print(_DNormal,"Iterating %6.2f %% done\r",
	    (currentiteration+1)*100.0/TotalIterations); 
    if (itINI.IterationType==1)
      currentrow=currentiteration%ARows; 
    else {
      //currentrow=(int)(ARows*(float)rand()/(RAND_MAX+1.0));
      GetRNGstate();
      currentrow = (int)(ARows*runif(0, 1));
      //currentrow = (int)(ARows*runif(0, RAND_MAX)/(RAND_MAX+1.0));
      PutRNGstate();
    }

    AVector=GenerateAMatrixRow(currentrow); 
    denom=MultVectorVector(AVector,AVector);
    if (fabs(denom)>1e-9)
    {
      brk=lambda*(tempBv[currentrow]-MultVectorVector(AVector,xvector))/denom;       
      ARTUpdateAddVector2(xvector, AVector, brk);
    }      
    FreeVector(AVector);

    if ( (itINI.SaveIterations) && (currentiteration != 0) && (!(currentiteration%(ARows*(itINI.SaveIterations)))) )
      SaveIteration(xvector,(int)(currentiteration/ARows),itINI.SaveIterationsName);
    
    if (UseRefImage==1)
      if (currentiteration%AntPrint==0)
	  fprintf(DiffFile,"%f %f\n",(double)currentiteration/ARows,
		    (double)L2NormVector(refxvector,xvector)); 
	  /*fprintf(DiffFile,"%f %f\n",(double)currentiteration/ARows,
		    (double)L2NormVector(refxvector,xvector,refxdev));*/
  }
  Print(_DNormal,"                                                  \r");
  Recon=VectorToImage(xvector,itINI.XSamples,itINI.YSamples);
  if (UseRefImage==1){
    Print(_DNormal,"L2 = %9.6f \n",L2NormVector(refxvector,xvector));
    //Print(_DNormal,"L2 = %9.6f \n",L2NormVector(refxvector,xvector,refxdev));
    FreeVector(refxvector);
    fclose(DiffFile);
  }
  
  RenameImage(Recon,"ReconstructedImage");
  Recon->DeltaX=itINI.DeltaX;
  Recon->DeltaY=itINI.DeltaY;
  Recon->Xmin=itINI.Xmin;
  Recon->Ymin=itINI.Ymin;
  
  return Recon;
}