00001 #include <vector>
00002 #include "Basis/CmdOptions.h"
00003 #include "Basis/Timer.h"
00004 #include "Util/TimePlot.h"
00005 #include "Core/Array/Arrays.h"
00006 #include "Core/Array/Set.h"
00007 #include "Core/Array/RGB2Intensity.h"
00008 #include "Core/Array/GaussDerivative.h"
00009 #include "Core/Array/RecGauss.h"
00010 #include "Core/Array/RecGabor.h"
00011 #include "Core/Array/ReadRaw.h"
00012 #include "Core/Array/WriteRaw.h"
00013 #include "Core/Array/Norm2.h"
00014
00015 namespace Impala
00016 {
00017 namespace Samples
00018 {
00019 namespace Timing
00020 {
00021
00022
00023 using namespace Impala::Util;
00024 using namespace Impala::Core::Array;
00025
00026 void
00027 DoOneConvSep(String machineName, String srcName, int runCount)
00028 {
00029 Array2dVec3UInt8* srcData = 0;
00030 ReadRaw(srcData, srcName, &Util::Database::GetInstance());
00031 int borderSize = 39;
00032 Array2dScalarReal64* rData;
00033 rData = ArrayClone<Array2dScalarReal64>(srcData, borderSize, borderSize);
00034 RGB2Intensity(rData, srcData);
00035 delete srcData;
00036
00037 int f, g, i;
00038
00039 const int numFunc = 3;
00040 const int numGauss = 10;
00041 Array2dScalarReal64* gauss[numGauss];
00042 gauss[0] = MakeGaussian1d(1.0, 0, 2.0, 3);
00043 gauss[1] = MakeGaussian1d(1.0, 0, 3.0, 100);
00044 gauss[2] = MakeGaussian1d(1.0, 0, 5.0, 100);
00045 gauss[3] = MakeGaussian1d(1.7, 0, 4.0, 100);
00046 gauss[4] = MakeGaussian1d(2.3, 1, 4.0, 100);
00047 gauss[5] = MakeGaussian1d(2.7, 1, 4.0, 100);
00048 gauss[6] = MakeGaussian1d(3.2, 1, 4.0, 100);
00049 gauss[7] = MakeGaussian1d(3.7, 1, 4.0, 100);
00050 gauss[8] = MakeGaussian1d(4.2, 1, 4.0, 100);
00051 gauss[9] = MakeGaussian1d(4.7, 1, 4.0, 100);
00052 int gaussSize[numGauss];
00053 for (i=0 ; i<numGauss ; i++)
00054 gaussSize[i] = gauss[i]->CW();
00055 int nrSplitTimes = 5;
00056 TimePlot plotter(numFunc, numGauss, gaussSize, nrSplitTimes, runCount);
00057
00058 Array2dScalarReal64* res = ArrayClone<Array2dScalarReal64>(rData);
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073 for (i=0 ; i<runCount ; i++)
00074 {
00075 for (g=0 ; g<numGauss ; g++)
00076 {
00077 for (f=0 ; f<numFunc ; f++)
00078 {
00079 plotter.Start(f, g, i);
00080 ConvKernelSeparated(res, rData, gauss[g], gauss[g], f, &plotter);
00081 plotter.Stop();
00082 }
00083 }
00084 }
00085
00086 String* funcName = new String[numFunc];
00087 funcName[0] = "0nai";
00088 funcName[1] = "1sim";
00089 funcName[2] = "2siminc";
00090
00091
00092
00093
00094
00095
00096
00097
00098 String baseName = srcName.substr(0, srcName.find('.'));
00099 plotter.SaveData(machineName, String("convsep"), baseName, funcName);
00100
00101 delete [] funcName;
00102 delete rData;
00103 delete res;
00104 }
00105
00106 void
00107 DoConvSep(String machineName)
00108 {
00109 DoOneConvSep(machineName, "trui_256.raw", 10);
00110 DoOneConvSep(machineName, "trui_255.raw", 5);
00111 DoOneConvSep(machineName, "trui_257.raw", 5);
00112 DoOneConvSep(machineName, "trui_352x288.raw", 5);
00113 DoOneConvSep(machineName, "trui_512.raw", 5);
00114 DoOneConvSep(machineName, "trui_720x576.raw", 5);
00115 DoOneConvSep(machineName, "trui_1280.raw", 5);
00116 }
00117
00118 void
00119 DoOneRecConvSep(String machineName, String srcName, int runCount)
00120 {
00121 Array2dVec3UInt8* srcData = 0;
00122 ReadRaw(srcData, srcName, &Util::Database::GetInstance());
00123 int borderSize = 22;
00124 Array2dScalarReal64* rData;
00125 rData = ArrayClone<Array2dScalarReal64>(srcData, borderSize, borderSize);
00126 RGB2Intensity(rData, srcData);
00127 delete srcData;
00128
00129 int f, g, i;
00130 const int numFunc = 1;
00131 const int numGauss = 5;
00132 Array2dScalarReal64* gauss[numGauss];
00133 gauss[0] = MakeGaussIIR1d(5.0, 0, 1);
00134 gauss[1] = MakeGaussIIR1d(5.0, 0, 2);
00135 gauss[2] = MakeGaussIIR1d(5.0, 0, 3);
00136 gauss[3] = MakeGaussIIR1d(5.0, 0, 4);
00137 gauss[4] = MakeGaussIIR1d(5.0, 0, 5);
00138 int gaussSize[numGauss];
00139 for (i=0 ; i<numGauss ; i++)
00140 gaussSize[i] = gauss[i]->CW();
00141 int nrSplitTimes = 4;
00142 TimePlot plotter(numFunc, numGauss, gaussSize, nrSplitTimes, runCount);
00143
00144 Array2dScalarReal64* res = ArrayClone<Array2dScalarReal64>(rData);
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159 for (i=0 ; i<runCount ; i++)
00160 {
00161 for (g=0 ; g<numGauss ; g++)
00162 {
00163 for (f=0 ; f<numFunc ; f++)
00164 {
00165 plotter.Start(f, g, i);
00166 RecConvKernelSeparated(res, rData, gauss[g], gauss[g], &plotter);
00167 plotter.Stop();
00168 }
00169 }
00170 }
00171
00172 String* funcName = new String[numFunc];
00173 funcName[0] = "only variation";
00174
00175 String baseName = srcName.substr(0, srcName.find('.'));
00176 plotter.SaveData(machineName, String("recconvsep"), baseName, funcName);
00177
00178 delete [] funcName;
00179 delete rData;
00180 delete res;
00181 }
00182
00183 void
00184 DoRecConvSep(String machineName)
00185 {
00186 DoOneRecConvSep(machineName, "trui_256.raw", 10);
00187 DoOneRecConvSep(machineName, "trui_255.raw", 5);
00188 DoOneRecConvSep(machineName, "trui_257.raw", 5);
00189 DoOneRecConvSep(machineName, "trui_352x288.raw", 5);
00190 DoOneRecConvSep(machineName, "trui_512.raw", 5);
00191 DoOneRecConvSep(machineName, "trui_720x576.raw", 5);
00192 DoOneRecConvSep(machineName, "trui_1280.raw", 5);
00193 }
00194
00195 void
00196 DoOneRecConvSepComlex(String machineName, String srcName, int runCount)
00197 {
00198 Array2dVec3UInt8* srcData = 0;
00199 ReadRaw(srcData, srcName, &Util::Database::GetInstance());
00200 int borderSize = 22;
00201 Array2dScalarReal64* rData;
00202 rData = ArrayClone<Array2dScalarReal64>(srcData, borderSize, borderSize);
00203 RGB2Intensity(rData, srcData);
00204 delete srcData;
00205 Array2dComplex64* comData = 0;
00206 Set(comData, rData);
00207
00208 int f, g, i;
00209 const int numFunc = 2;
00210 const int numGabor = 1;
00211 Array2dComplex64* gabor;
00212 Complex64 leftBorder;
00213 Complex64 rightBorder;
00214 gabor = MakeGaborIIR1d(6.0, 1, leftBorder, rightBorder);
00215 int gaborSize = gabor->CW();
00216 int nrSplitTimes = 4;
00217 TimePlot plotter(numFunc, numGabor, &gaborSize, nrSplitTimes, runCount);
00218
00219 Array2dComplex64* res = ArrayClone<Array2dComplex64>(comData);
00220
00221 for (i=0 ; i<runCount ; i++)
00222 {
00223 for (g=0 ; g<numGabor ; g++)
00224 {
00225 for (f=0 ; f<numFunc ; f++)
00226 {
00227 plotter.Start(f, g, i);
00228 RecConvKernelSeparated(res, comData, gabor, gabor,
00229 leftBorder, rightBorder,
00230 leftBorder, rightBorder, &plotter);
00231 if (f == 1)
00232 Norm2(rData, res);
00233 plotter.Stop();
00234 }
00235 }
00236 }
00237
00238 String* funcName = new String[numFunc];
00239 funcName[0] = "recconvsepcomplex";
00240 funcName[1] = "recconvsepcomplex + norm";
00241
00242 String baseName = srcName.substr(0, srcName.find('.'));
00243 plotter.SaveData(machineName, String("recconvsepcomplex"), baseName,
00244 funcName);
00245
00246 delete [] funcName;
00247 delete rData;
00248 delete comData;
00249 delete res;
00250 }
00251
00252 void
00253 DoRecConvSepComlex(String machineName)
00254 {
00255 DoOneRecConvSepComlex(machineName, "trui_256.raw", 10);
00256 DoOneRecConvSepComlex(machineName, "trui_255.raw", 5);
00257 DoOneRecConvSepComlex(machineName, "trui_257.raw", 5);
00258 DoOneRecConvSepComlex(machineName, "trui_352x288.raw", 5);
00259 DoOneRecConvSepComlex(machineName, "trui_512.raw", 5);
00260 DoOneRecConvSepComlex(machineName, "trui_720x576.raw", 5);
00261 DoOneRecConvSepComlex(machineName, "trui_1280.raw", 5);
00262 }
00263
00264 void
00265 ShowUsage(char *progName)
00266 {
00267 std::cout
00268 << "Usage : " << std::endl
00269 << progName << " cmd [options for cmd]" << std::endl
00270 << " convsep machine" << std::endl
00271 << " recconvsep machine" << std::endl
00272 << " recconvsepcomplex machine" << std::endl
00273 ;
00274 }
00275
00276 int
00277 mainTiming(int argc, char* argv[])
00278 {
00279 CmdOptions& options = CmdOptions::GetInstance();
00280 options.Initialise(false, false, true);
00281 String usageStr = "cmd machine, where cmd can be\n";
00282 usageStr += " convsep, recconvsep or recconvsepcomple";
00283 if (! options.ParseArgs(argc, argv, usageStr, 2))
00284 return 1;
00285
00286 String cmd = options.GetArg(0);
00287 String machine = options.GetArg(1);
00288 if (cmd == "convsep")
00289 DoConvSep(machine);
00290 else if (cmd == "recconvsep")
00291 DoRecConvSep(machine);
00292 else if (cmd == "recconvsepcomplex")
00293 DoRecConvSepComlex(machine);
00294 else std::cout << "Unknown cmd : " << cmd << std::endl;
00295
00296 return 0;
00297 }
00298
00299 }
00300 }
00301 }
00302
00303 int
00304 main(int argc, char* argv[])
00305 {
00306 try{
00307 return Impala::Samples::Timing::mainTiming(argc, argv);
00308 }
00309 catch(...)
00310 {
00311 std::cout << std::endl;
00312 return 1;
00313 }
00314 }