VarExprReturnSP LitMatrixExprReturn::convertToVarExprReturn( VarExprReturn &varExprReturn ) {
SFC::DT dt = getDT();
// assert( dt == varExprReturn.getDT() );
SFCTypesManager::DimensionVector dimensionVector = SFCTypesManager::getDimensions( dt );
if ( dimensionVector.empty() ) {
Exprs exprs = DE( getSequence().front() );
VarExprReturnSP varExprReturnSP = VarExprReturn::create( getBlock(), exprs, ExprsProxyVector(), SFCTypesManager::getSingleton().getBasicType( "double" ) );
varExprReturn.combine( "=", varExprReturnSP )->collapse();
return VarExprReturn::create( varExprReturn );
}
SFCTypesManager::DimensionVector countVector( dimensionVector.size(), 0 );
for( Sequence::iterator sqnItr = getSequence().begin() ; sqnItr != getSequence().end() ; ++sqnItr ) {
for( unsigned int ix = 0 ; ix < (unsigned int) dimensionVector.size() ; ++ix ) {
varExprReturn.getExprsProxyVector()[ ix ].setExprs( IE( countVector[ ix ] ) );
}
Exprs exprs = BE( varExprReturn.getExprs(), "=", DE( *sqnItr ) );
exprs.buildUdm( getBlock(), SFC::CompoundStatement::meta_stmnt );
for( int ix = dimensionVector.size() ; --ix >= 0 ;) {
if ( ++countVector[ix] < dimensionVector[ix] ) break;
countVector[ix] = 0;
}
}
return VarExprReturn::create( varExprReturn );
}
Image makeComplexImage(const Image jetImage){
Image complexImage = makeImage(jetImage->width, jetImage->height, jetImage->channels/2);
int x,y,c;
DEBUG_CHECK(jetImage->channels%2 == 0,"jetImage must have an even number of channels");
for(x = 0; x < complexImage->width; x++){
for(y = 0; y < complexImage->height; y++){
for(c = 0; c < complexImage->channels; c++){
IE(complexImage,x,y,c) =
sqrt(SQR(IE(jetImage,x,y,c*2))+
SQR(IE(jetImage,x,y,c*2+1)));
}
}
}
return complexImage;
}
/* GraphView::LoadImage(Image img)
* This fuction copies data from an Image into a QImage that is displayed in the
* widget.
*/
void GraphView::loadImage(Image img){
im = img;
image = QImage(width(),height(),32);
if(im){
float min = IE(im,0,0,0);
float max = IE(im,0,0,0);
for(int x = 0; x < im->width; x++){
for(int y = 0; y < im->height; y++){
for(int c = 0; c < im->channels; c++){
if(min > IE(im,x,y,c)) min = IE(im,x,y,c);
if(max < IE(im,x,y,c)) max = IE(im,x,y,c);
}
}
}
double iScale = im->width/(double)image.width();
double jScale = im->height/(double)image.height();
for(int i = 0; i < image.width(); i++){
for(int j = 0; j < image.height(); j++){
int level = ROUND(255.0 * (interpLinear(im,i*iScale,j*jScale,0) - min )/(max-min));
image.setPixel(i,j,(uint)qRgb(level,level,level));
}
}
}
repaint(TRUE);
}
SS DFStatement::buildSS(
const StringList &inVarNameList, const DoubleList &inCoefList,
const StringList &outVarNameList, const DoubleList &outCoefList
) {
//
// FIRST, BUILD THE FILTER EQUATION
//
StringList::const_iterator inVarNameItr = inVarNameList.begin();
DoubleList::const_iterator inCoefItr = inCoefList.begin();
StringList::const_iterator outVarNameItr = outVarNameList.begin();
DoubleList::const_iterator outCoefItr = outCoefList.begin();
BE be( 0, "+", BE( *inCoefItr, "*", *inVarNameItr ) );
while( ++inVarNameItr != inVarNameList.end() ) {
(void)++inCoefItr;
be = BE( be, "+", BE( *inCoefItr, "*", *inVarNameItr ) );
}
while( ++outVarNameItr != outVarNameList.end() ) {
(void)++outCoefItr;
be = BE( be, "-", BE( *outCoefItr, "*", *outVarNameItr ) );
}
be = BE( be, "/", outCoefList.front() );
be = BE( outVarNameList.front(), "=", be );
//
// SHIFT THE VARIABLES
//
SS ss( IE( 1 ), be );
(void)--inVarNameItr;
while( inVarNameItr != inVarNameList.begin() ) {
StringList::const_iterator nxtInVarNameItr = inVarNameItr;
(void)--nxtInVarNameItr;
ss = SS( ss, BE( *inVarNameItr, "=", *nxtInVarNameItr ) );
inVarNameItr = nxtInVarNameItr;
}
(void)--outVarNameItr;
while( outVarNameItr != outVarNameList.begin() ) {
StringList::const_iterator nxtOutVarNameItr = outVarNameItr;
(void)--nxtOutVarNameItr;
ss = SS( ss, BE( *outVarNameItr, "=", *nxtOutVarNameItr ) );
outVarNameItr = nxtOutVarNameItr;
}
return ss;
}
Image makeJetImage(const JetMasks masks, Image im){
Image jets = makeImage(im->width,im->height,im->channels*(masks->size));
int n,x,y,c;
for(y = 0; y < im->height; y++){
for(x = 0; x < im->width; x++){
for(c = 0; c < im->channels;c++){
for(n = 0; n < masks->size; n++){
IE(jets,x,y,c*masks->size+n) = convolvePoint(x,y,c,im,masks->masks[n]);
}
}
}
}
return jets;
}
VarExprReturnSP LitMatrixExprReturn::convertToVarExprReturn( SFC::ArgDeclBase argDeclBase ) {
// IF TYPE ISN'T ARRAY, THEN IT MUST BE BASIC
if ( getDT().type() != SFC::Array::meta ) {
double value = getSequence().front();
// SEE IF value IS CAN BE ACCURATELY REPRESENTED AS AN INTEGER
Exprs exprs;
if ( int(value) <= INT_MAX && int( value ) == value ) exprs = IE( (int) value );
else exprs = DE( value );
return VarExprReturn::create( getBlock(), exprs, ExprsProxyVector(), getDT() );
}
if ( argDeclBase == Udm::null ) {
argDeclBase = SFCManager::createUniqueLocalVar( getBlock(), "result" );
argDeclBase.dt() = getDT();
}
VarExprReturnSP varExprReturnSP = VarExprReturn::create( getBlock(), argDeclBase, getDT() );
return convertToVarExprReturn( *varExprReturnSP );
}
/* This function performs a 3X3 two dimentional perspective transform to an image
This is used to perform geomentric normalization */
Image transformImage(Image source, int newWidth, int newHeight, const Matrix m){
Image dest = makeImage(newWidth, newHeight, source->channels);
Matrix point = makeMatrix(3,1);
Matrix inv;
Matrix pt;
int x, y, c;
assert(m->row_dim == 3);
assert(m->col_dim == 3);
/* initialize homogenius point */
ME(point,2,0) = 1;
/* find the inverse transformation to convert from dest to source */
inv = invertRREF(m);
for(x = 0; x < dest->width; x++){
for(y = 0; y < dest->height; y++){
/* calculate source point */
ME(point,0,0) = x;
ME(point,1,0) = y;
ME(point,2,0) = 1.0;
pt = multiplyMatrix(inv, point);
ME(pt,0,0) = ME(pt,0,0) / ME(pt,2,0);
ME(pt,1,0) = ME(pt,1,0) / ME(pt,2,0);
for(c = 0; c < dest->channels; c++){
/* interpolate value */
IE(dest,x,y,c) = interpLinear(source, ME(pt,0,0),ME(pt,1,0),c);
}
/* clean up */
freeMatrix(pt);
}
}
freeMatrix(point);
freeMatrix(inv);
return dest;
}
Image makeGaborMask(FTYPE lambda, FTYPE theta, FTYPE phi,
FTYPE gamma, FTYPE sigma,int size)
{
Image mask = makeImage(size,size,1);
int i, j;
for(j = 0; j < size; j++){
for(i = 0; i < size; i++){
FTYPE x = size/2.0 - size + i;
FTYPE y = size/2.0 - size + j;
FTYPE xp = x*cos(theta)+y*sin(theta);
FTYPE yp = -x*sin(theta)+y*cos(theta);
FTYPE tmp1 = -(xp*xp+gamma*gamma*yp*yp)/(2*sigma*sigma);
FTYPE tmp2 = (2*PI*xp/lambda)+phi;
IE(mask,i,j,0) = exp(tmp1)*(cos(tmp2)-(phi == 0.0)*(WiskottDCFree)*exp(-sigma*sigma*0.5));
}
}
/* Rescale the pixel values to have a standard total length */
ZeroMeanUnitLength(mask);
return mask;
}
void convertImages(Arguments* args){
FILE* list;
JetMasks masks;
int x, y,i,j;
char imagename[MAX_FILENAME_LENGTH];
char filename[MAX_FILENAME_LENGTH];
MESSAGE("Creating gabor masks.");
masks = readMasksFile(args->maskFile);
if(args->saveMasks){
for(y = 0; y < masks->size; y++){
char outname[MAX_FILENAME_LENGTH];
sprintf(outname, "mask%03d.pgm",y);
writePGMImage(masks->masks[y],outname,0);
}
}
list = fopen(args->imageList,"r");
if(!list){
printf("Error opening file: %s\n", args->imageList);
exit(1);
}
while(fscanf(list, "%s", imagename) == 1){
Image im;
Image grid;
sprintf(filename, "%s/%s", args->inputDir, imagename);
im = readRawImage(filename);
MESSAGE1ARG("Processing file: %s",filename);
/* Find the number of points in the grid */
i = 0;
for( x = args->gridStartX; x < im->width; x += args->gridSpaceX){
for( y = args->gridStartY; y < im->height; y+= args->gridSpaceY){
i++;
}
}
grid = makeImage(i,masks->size,1);
/* Compute convolutions */
i = 0;
for( x = args->gridStartX; x < im->width; x += args->gridSpaceX){
for( y = args->gridStartY; y < im->height; y+= args->gridSpaceY){
for(j = 0; j < masks->size; j++){
if( i < grid->width )
IE(grid,i,j,0) = convolvePoint(x, y, 0, im, masks->masks[j]);
}
i++;
}
}
sprintf(filename, "%s/%s", args->sfiDir, imagename);
writeRawImage(grid,filename);
freeImage(grid);
freeImage(im);
}
fclose(list);
}
