int ComposeAffineWithFile( itk::AffineTransform< double , 3 >::Pointer &affineTransform1 , itk::TransformFileReader::Pointer &transformFile )
{
//Compose transforms
typedef itk::AffineTransform< double , 3 > AffineTransformType ;
AffineTransformType::Pointer affineTransform2 ;
while( transformFile->GetTransformList()->size() )
{
if( ReadTransform( transformFile , affineTransform2 ) )
{
return 1 ;
}
affineTransform1->Compose( affineTransform2 , true ) ;
}
return 0 ;
}
int ComposeAffineTransforms( int argc , char* argv[] )
{
if( argc != 5 )
{
std::cout<< argv[ 0 ] << " " << argv[ 1 ] << " Transform1 Transform2 outputTransform" << std::endl ;
return 1 ;
}
std::string input1 ;
input1.assign( argv[ 2 ] ) ;
std::string input2 ;
input2.assign( argv[ 3 ] ) ;
std::string output ;
output.assign( argv[ 4 ] ) ;
//Compose
typedef itk::AffineTransform< double , 3 > AffineTransformType ;
AffineTransformType::Pointer affineTransform ;
itk::TransformFileReader::Pointer transformFile ;
itk::TransformFactory< itk::MatrixOffsetTransformBase<double, 3, 3> >::RegisterTransform();
transformFile = itk::TransformFileReader::New() ;
transformFile->SetFileName( input1 ) ;
transformFile->Update() ;
ReadTransform( transformFile , affineTransform ) ;
if( ComposeAffineWithFile( affineTransform , transformFile ) )
{
return 1 ;
}
transformFile->SetFileName( input2 ) ;
transformFile->Update() ;
if( ComposeAffineWithFile( affineTransform , transformFile ) )
{
return 1 ;
}
//Save transform
itk::TransformFileWriter::Pointer outputTransformFile ;
outputTransformFile = itk::TransformFileWriter::New() ;
outputTransformFile->SetFileName( output.c_str() ) ;
outputTransformFile->SetInput( affineTransform ) ;
outputTransformFile->Update() ;
return 0 ;
}
int main( int argc, char** argv )
{
if (argc == 1) {
std::cerr << "Usage: ./transform_image -i source.pgm -o warped.pgm [-t warp.xfm] [mode]\n"
<< " Rotation angle: -a 60\n"
<< " Scale factor: -s 1.5\n"
<< " Use homography from file: -h warp.xfm\n";
return 0;
}
char *image_file = NULL, *transform_file = NULL, *homography_file = NULL;
std::string out_file = "warped.pgm";
float angle = 0; //degrees
float scaling = 0;
Mode mode = None;
int arg = 0;
while (++arg < argc) {
if (! strcmp(argv[arg], "-i"))
image_file = argv[++arg];
if (! strcmp(argv[arg], "-o"))
out_file = argv[++arg];
if (! strcmp(argv[arg], "-t"))
transform_file = argv[++arg];
if (! strcmp(argv[arg], "-a")) {
angle = atof(argv[++arg]);
mode = Rotate;
}
if (! strcmp(argv[arg], "-s")) {
scaling = atof(argv[++arg]);
mode = Scale;
}
if (! strcmp(argv[arg], "-h")) {
homography_file = argv[++arg];
mode = Transform;
}
}
assert(image_file);
assert(mode != None);
IplImage* loaded = cvLoadImage(image_file, CV_LOAD_IMAGE_GRAYSCALE);
assert(loaded);
int W = loaded->width;
int H = loaded->height;
CvMat* transform = NULL;
IplImage* warped = NULL;
int flags = CV_INTER_CUBIC | CV_WARP_FILL_OUTLIERS;
if (mode == Rotate) {
transform = cvCreateMat(2, 3, CV_32FC1);
CvSize warped_size = FullImageRotation(W, H, angle, transform);
warped = cvCreateImage(warped_size, IPL_DEPTH_8U, 1);
cvWarpAffine(loaded, warped, transform, flags);
}
else if (mode == Scale) {
transform = cvCreateMat(2, 3, CV_32FC1);
cvZero(transform);
float* data = transform->data.fl;
*data = scaling;
data[transform->step/sizeof(float) + 1] = scaling;
CvSize warped_size = cvSize(W*scaling + 0.5, H*scaling + 0.5);
warped = cvCreateImage(warped_size, IPL_DEPTH_8U, 1);
cvWarpAffine(loaded, warped, transform, flags);
}
else if (mode == Transform) {
transform = cvCreateMat(3, 3, CV_32FC1);
ReadTransform(homography_file, transform);
warped = cvCreateImage(cvSize(W, H), IPL_DEPTH_8U, 1);
cvWarpPerspective(loaded, warped, transform, flags);
}
cvSaveImage(out_file.c_str(), warped);
if (transform_file)
WriteTransform(transform_file, transform);
return 0;
}
int main( int argc, char** argv )
{
if (argc == 1)
{
std::cerr << "Usage: ./sift_detect -i image.pgm -o image.key "
<< "[-t warp.xfm -i2 warped.pgm -o2 warped.key] [options]\n"
<< " number of points to take: -p 800\n"
<< " scale upper bound 1: -ub1 6\n"
<< " scale lower bound 1: -lb1 2\n"
<< " scale upper bound 2: -ub2 9\n"
<< " scale lower bound 2: -lb2 2.8\n";
return 0;
}
char *image_file = NULL, *warped_file = NULL, *transform_file = NULL;
int num_points = 800;
std::string key_file = "source.key", warped_key_file = "warped.key";
float scale_ub1 = -1, scale_lb1 = -1, scale_ub2 = -1, scale_lb2 = -1;
int arg = 0;
while (++arg < argc)
{
if (! strcmp(argv[arg], "-i"))
image_file = argv[++arg];
if (! strcmp(argv[arg], "-i2"))
warped_file = argv[++arg];
if (! strcmp(argv[arg], "-t"))
transform_file = argv[++arg];
if (! strcmp(argv[arg], "-o"))
key_file = argv[++arg];
if (! strcmp(argv[arg], "-o2"))
warped_key_file = argv[++arg];
if (! strcmp(argv[arg], "-p"))
num_points = atoi(argv[++arg]);
if (! strcmp(argv[arg], "-ub1"))
scale_ub1 = atof(argv[++arg]);
if (! strcmp(argv[arg], "-lb1"))
scale_lb1 = atof(argv[++arg]);
if (! strcmp(argv[arg], "-ub2"))
scale_ub2 = atof(argv[++arg]);
if (! strcmp(argv[arg], "-lb2"))
scale_lb2 = atof(argv[++arg]);
}
assert(image_file);
assert(!warped_file || transform_file);
// Load the source image
Image im = ReadPGMFile(image_file);
int W = im->cols;
int H = im->rows;
// Find keypoints in source image
LoweKeypoint lowe_keypts = NULL;
{
Timer t("SIFT detector");
lowe_keypts = GetKeypoints(im);
}
std::vector<KeypointFl> keypts;
for (LoweKeypoint pt = lowe_keypts; pt != NULL; pt = pt->next)
{
keypts.push_back(KeypointFl(pt->col, pt->row, pt->scale, pt->strength));
}
if (scale_ub1 > 0)
keypts.erase(std::remove_if(keypts.begin(), keypts.end(),
ScaleUpperBound(scale_ub1)),
keypts.end());
if (scale_lb1 > 0)
keypts.erase(std::remove_if(keypts.begin(), keypts.end(),
ScaleLowerBound(scale_lb1)),
keypts.end());
Image warped = NULL;
CvMat *transform = NULL, *inv = NULL;
if (warped_file)
{
warped = ReadPGMFile(warped_file);
// Get inverse transform (warped -> source)
transform = cvCreateMat(3, 3, CV_32FC1);
ReadTransform(transform_file, transform);
inv = cvCreateMat(3, 3, CV_32FC1);
cvInvert(transform, inv);
keypts.erase(std::remove_if(keypts.begin(), keypts.end(),
OutsideSource(warped->cols, warped->rows, transform)),
keypts.end());
}
if ((int)keypts.size() < num_points)
{
num_points = keypts.size();
printf("WARNING: Only taking %d points!\n", num_points);
std::sort(keypts.begin(), keypts.end());
}
else
{
std::partial_sort(keypts.begin(), keypts.begin()+ num_points, keypts.end());
}
if (warped_file)
{
// Find keypoints in warped image
LoweKeypoint lowe_warp_keypts = NULL;
{
Timer t("SIFT detector (warped)");
lowe_warp_keypts = GetKeypoints(warped);
}
std::vector<KeypointFl> warp_keypts;
for (LoweKeypoint pt = lowe_warp_keypts; pt != NULL; pt = pt->next)
{
warp_keypts.push_back(KeypointFl(pt->col, pt->row, pt->scale, pt->strength));
}
if (scale_ub2 > 0)
warp_keypts.erase(std::remove_if(warp_keypts.begin(), warp_keypts.end(),
ScaleUpperBound(scale_ub2)),
warp_keypts.end());
if (scale_lb2 > 0)
warp_keypts.erase(std::remove_if(warp_keypts.begin(), warp_keypts.end(),
ScaleLowerBound(scale_lb2)),
warp_keypts.end());
warp_keypts.erase(std::remove_if(warp_keypts.begin(), warp_keypts.end(),
OutsideSource(W, H, inv)),
warp_keypts.end());
if ((int)warp_keypts.size() < num_points)
{
num_points = warp_keypts.size();
printf("WARNING: Only taking %d points!\n", num_points);
std::sort(warp_keypts.begin(), warp_keypts.end());
}
else
{
std::partial_sort(warp_keypts.begin(), warp_keypts.begin() + num_points,
warp_keypts.end());
warp_keypts.erase(warp_keypts.begin() + num_points, warp_keypts.end());
}
WriteKeypointsFl(warped_key_file, warp_keypts);
}
keypts.erase(keypts.begin() + num_points, keypts.end());
WriteKeypointsFl(key_file, keypts);
cvReleaseMat(&inv);
cvReleaseMat(&transform);
delete warped;
delete im;
return 0;
}
