View difference between Paste ID: BmEwUYxx and nkCpAqB8

 
 
     /* compile with
      *
-     *      g++ -Wall test.cpp `pkg-config vipsCC --cflags --libs`
+     *      g++ -Wall test_image_resize.cpp `pkg-config vipsCC --cflags --libs`
      *
      */
 
     #include <iostream>
     #include <fstream>
     #include <sstream>
     #include <string>
     #include <algorithm>
 
     #include <vips/vips>
     #include <vips/vips.h>
 
     #define PROGRESSIVE 1
 
     /* Macro to convert integer to string */
     #define SSTR( x ) dynamic_cast< std::ostringstream & > ( ( std::ostringstream() << std::dec << x ) ).str()
 
 
 
     /**
      *
      * @param inputname : absolute path of the file. [ /home/vinod/test_code/test.cpp ]
      * @param path      : the path. [ /home/vinod/test_code ]
      * @param name      : the name. [ test ]
      * @param ext       : the extension. [ cpp ]
      */
     void split_path_name_ext(std::string &inputname, std::string &path, std::string &name, std::string &ext)
     {
             path = inputname.substr(0, inputname.find_last_of("/"));
             name = inputname.substr(inputname.find_last_of("/") + 1,
                                     inputname.find_last_of(".") - inputname.find_last_of("/") - 1);
             ext = inputname.substr(inputname.find_last_of(".") + 1);
             return;
     }
 
     /**
      *
      * @param ifilename : name of the image file to be resized.
      * @return 0 on success.
      */
     int image_resize(std::string& ifilename)
     {
 
 
         int height[]={1080,720,480,360,240};
         int n_files = sizeof(height)/sizeof(height[0]);
         std::string path , name , ext;
         split_path_name_ext(ifilename,path,name,ext);
 
         /* The vips7 C++ interface doesn't support the open mode we need.
          */
-        if (vips_foreign_load (ifilename.c_str (), &x,
+
-                             "access", VIPS_ACCESS_SEQUENTIAL, NULL)){
+        std::transform(ext.begin(),ext.end(),ext.begin(),::tolower);
 
         if (vips_foreign_load (ifilename.c_str (), &x, NULL)){
             std::cout<<"cant load - "<<ifilename<<std::endl;
             return -1;
         }
 
 
 
         vips::VImage im (x);
         im._ref->close_on_delete = 1;
         double aspect_ratio = double(im.Xsize()) / double(im.Ysize());
 
         vips::VImage * out;
         out = new vips::VImage [n_files + 1];
         out[0] = im;
         int k=0;
         for(int i=0; i < n_files ; i++)
         {
             int input_height = out[i].Ysize();
             int target_height = height[i];
             int target_width = (int(target_height * aspect_ratio) /2 )*2;
 
             /* I need not upsample */
             if (target_height > input_height) {
                 out[i + 1] = out[i];
                 continue;
             }
 
             double scale = target_height / (double) input_height;
             /* Shrink to integer factor first - This is faster
              */
             int shrink_factor = floor (1.0 / scale);
             if ((1.0 / scale) > 2.0)
             {
               out[i] = out[i].shrink (double (shrink_factor), double (shrink_factor));
-            int tile_width;
+
-            int tile_height;
+
-            int nlines;
+
              */
-            VipsImage * temp;
+            if(ext.find("png")!=std::string::npos ){
-            vips_get_tile_size (out[i].image (), &tile_width, &tile_height, &nlines);
+                int tile_width;
-            if (vips_tilecache (out[i].image (), &temp,
+                int tile_height;
-                              "tile_width", out[i].Xsize (),
+                int nlines;
-                              "tile_height", 10,
+                VipsImage * temp;
-                              "max_tiles", (nlines * 2) / 10,
+                vips_get_tile_size (out[i].image (), &tile_width, &tile_height, &nlines);
-                              "access", VIPS_ACCESS_SEQUENTIAL,
+                if (vips_tilecache (out[i].image (), &temp,
-                              "threaded", TRUE, NULL))
+                                  "tile_width", out[i].Xsize (),
-            vips_error_exit ("can't cache");
+                                  "tile_height", 10,
-            out[i+1] = vips::VImage(temp);
+                                  "max_tiles", (nlines * 2) / 10,
-            out[i+1]._ref->close_on_delete = 1;
+                                  "access", VIPS_ACCESS_SEQUENTIAL,
-            out[i+1]._ref->addref (out[i]._ref);
+                                  "threaded", TRUE, NULL))
                 vips_error_exit ("can't cache");
                 out[i+1] = vips::VImage(temp);
                 out[i+1]._ref->close_on_delete = 1;
                 out[i+1]._ref->addref (out[i]._ref);
             }
             else
                 out[i+1] = out[i];
 
             /* Use affine transform to get to the required size */
             int height_aft_shrink = floor (input_height / shrink_factor);
 
             scale = target_height / (double) height_aft_shrink;
             out[i+1] = out[i+1].affinei ("bicubic", scale, 0, 0, scale,
                              0, 0, 0, 0, target_width, target_height);
 
             /* Apply Sharpening Filter */
             if (target_width < 150 || target_height < 150)
             {
                 /* Sharpening Filter*/
                 vips::VIMask sharpen_filter (3, 3, 8, 0,
                                            -1, -1, -1, -1, 16, -1, -1, -1, -1);
                 out[i+1] = out[i+1].conv (sharpen_filter);
             }
 
 
             std::string ofilename = path + "/" + name + "_" + SSTR(target_height) + ".jpg";
             std::cout << "starting save for " << ofilename << " ..." << std::endl;
             if (vips_foreign_save ((VipsImage *) (out[i+1].image ()),
                                     (char *) ofilename.c_str (),
                                     "interlace", PROGRESSIVE, NULL))
             {
               std::cout << "Error in saving file: " << ofilename << std::endl;
               std::cout << vips_error_buffer () << std::endl;
             }
             else
                 k++;
 
         }
         delete [] out;
         return 0;
 
     }
 
     int
     main (int argc, char **argv)
     {
       if (vips_init (argv[0]))
          vips_error_exit ("unable to init");
 
       GOptionContext *context;
       GError *error = NULL;
 
       context = g_option_context_new ("- test prog");
 
       g_option_context_add_group (context, vips_get_option_group ());
 
       if (!g_option_context_parse (context, &argc, &argv, &error))
         {
-
+
-      std::string filelist("/home/vinod/simple_tests/filelist.txt");
+
-      std::ifstream filehandle(filelist.c_str());
+
-      while(!filehandle.eof())
+
-      {
+
-          std::string ifilename;
+
-          getline(filehandle, ifilename);
+
-          if(ifilename.size()!=0)
+
 
-              image_resize(ifilename);
+
 
 
 
       for(int i=1;i<20;i++) {
           std::string filelist("/home/vinod/simple_tests/filelist.txt");
           std::ifstream filehandle(filelist.c_str());
           while(!filehandle.eof())
           {
               std::string ifilename;
               getline(filehandle, ifilename);
               if(ifilename.size()!=0)
               {
                   image_resize(ifilename);
               }
           }
           filehandle.close();
       }
 
       return 0;
     }