diff --git a/.hgignore b/.hgignore new file mode 100644 index 0000000..cbe790a --- /dev/null +++ b/.hgignore @@ -0,0 +1,9 @@ +relre:.*\.(idb|pdb|user|ilk|rar|old) +relre:.*\.(obj|exe|dll) +relre:.*\.(suo|ncb) +relre:.*\.(pch|dep|exp) +relre:.*\.(tlh|tli|log) +relre:.*\.(res|aps) + +syntax: regexp +.*\.(tlog) diff --git a/Calculation2D.sln b/Calculation2D.sln new file mode 100644 index 0000000..2e6a347 --- /dev/null +++ b/Calculation2D.sln @@ -0,0 +1,44 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{414A41D2-9FF0-4282-98E6-72B308485C32}" + ProjectSection(SolutionItems) = preProject + README.md = README.md + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "calc2d", "proj\calc2d\calc2d.vcxproj", "{51B17ACA-BAC0-408E-8145-B366393F0734}" + ProjectSection(ProjectDependencies) = postProject + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE} = {81764A51-4B0F-4310-ACD1-059BFC9BEDDE} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libcalc2d", "proj\libcalc2d\Calculation2D.vcxproj", "{81764A51-4B0F-4310-ACD1-059BFC9BEDDE}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {51B17ACA-BAC0-408E-8145-B366393F0734}.Debug|Win32.ActiveCfg = Debug|Win32 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Debug|Win32.Build.0 = Debug|Win32 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Debug|x64.ActiveCfg = Debug|x64 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Debug|x64.Build.0 = Debug|x64 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Release|Win32.ActiveCfg = Release|Win32 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Release|Win32.Build.0 = Release|Win32 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Release|x64.ActiveCfg = Release|x64 + {51B17ACA-BAC0-408E-8145-B366393F0734}.Release|x64.Build.0 = Release|x64 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Debug|Win32.ActiveCfg = Debug|Win32 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Debug|Win32.Build.0 = Debug|Win32 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Debug|x64.ActiveCfg = Debug|x64 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Debug|x64.Build.0 = Debug|x64 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Release|Win32.ActiveCfg = Release|Win32 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Release|Win32.Build.0 = Release|Win32 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Release|x64.ActiveCfg = Release|x64 + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/README.md b/README.md new file mode 100644 index 0000000..f118836 --- /dev/null +++ b/README.md @@ -0,0 +1,21 @@ +# Calculation2D +**Extensible image processing framework for C++** +*** + +## Installation + +## Quick start + +## Features + + +*** +###The MIT License (MIT) + +Copyright (c) 2012 OGX|OPTOGRAPHX + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/include/interfaces/mmGlobalInterfacesStorage.h b/include/interfaces/mmGlobalInterfacesStorage.h new file mode 100644 index 0000000..52887c8 --- /dev/null +++ b/include/interfaces/mmGlobalInterfacesStorage.h @@ -0,0 +1,74 @@ +//****************************************************************************** +//****************************************************************************** +// +// Global Interfaces Storage class +// +// +// Description: Class with pointers to global interfaces initialized objects. +// It is used for exchange of main interface objects between +// core of the system and other components. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmGlobalInterfacesStorageH +#define mmGlobalInterfacesStorageH + +#include + + +//////////////////////////////////////////////////////////////////////////////// +/// Namespace for interface initializers. +//////////////////////////////////////////////////////////////////////////////// +namespace mmInterfacesStorage +{ + ////////////////////////////////////////////////////////////////////////////////// + ///// Class for storage of pointers into main interfaces classes. + ////////////////////////////////////////////////////////////////////////////////// + //class mmGlobalInterfacesStorage: public mmLog::mmLogSender + //{ + // private: // members + // //////////////////////////////////////////////////////////////////////////////// + // /// Pointer for private storage of memory manager object. + // //////////////////////////////////////////////////////////////////////////////// + // mmMemory::mmMemoryManagerI* m_psMemoryManager; + + // public: // methods + // //////////////////////////////////////////////////////////////////////////////// + // /// This constructor initializes all private members. + // /// + // /// @param[in] p_psMemoryManager pointer to memory manager object. + // /// @param[in] p_psLogReceiver pointer to log object. + // /// @param[in] p_psMainWindow pointer to main window object. + // //////////////////////////////////////////////////////////////////////////////// + // mmGlobalInterfacesStorage( mmMemory::mmMemoryManagerI* p_psMemoryManager, mmLog::mmLogReceiverI* p_psLogReceiver ); + + // //////////////////////////////////////////////////////////////////////////////// + // /// Desctructor. + // //////////////////////////////////////////////////////////////////////////////// + // ~mmGlobalInterfacesStorage(); + + // //////////////////////////////////////////////////////////////////////////////// + // /// Method returns pointer to memory manager object. + // /// + // /// @return pointer to memory manager object + // //////////////////////////////////////////////////////////////////////////////// + // mmMemory::mmMemoryManagerI* GetMemoryManager(void); + + // //////////////////////////////////////////////////////////////////////////////// + // /// Method returns pointer to log object. + // /// + // /// @return pointer to log object + // //////////////////////////////////////////////////////////////////////////////// + // mmLog::mmLogReceiverI* GetLogManager(void); + + //}; + struct mmGlobalInterfacesStorage { + mmGlobalInterfacesStorage( mmLog::mmLogReceiverI* p_psLogReceiver ); + mmLog::mmLogReceiverI* GetLogManager(void); + mmLog::mmLogReceiverI* GetLogReceiver(void); + private: + mmLog::mmLogReceiverI* m_psLogReceiver; + }; +}; + +#endif diff --git a/include/interfaces/mmICalcMethod.h b/include/interfaces/mmICalcMethod.h new file mode 100644 index 0000000..c76607f --- /dev/null +++ b/include/interfaces/mmICalcMethod.h @@ -0,0 +1,100 @@ +#pragma once + +#include + +//****************************************************************************** +//****************************************************************************** +// +// Simple interface for calculation method +// +// Description: This header defines class mmCalcKernelI for function objects +// which implement operation on a single data block within the image and class +// mmCalcMethodI which offers simple interface to calculation method. It is a +// wrapper for mmImagesCalculationMethodI interface and is meant to be overloaded +// by developer +// +//****************************************************************************** +//****************************************************************************** + +namespace mmImages { + //////////////////////////////////////////////////////////////////////////////// + /// Interface representing function object for operation on single data block + //////////////////////////////////////////////////////////////////////////////// + class mmCalcKernelI + { + public: + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmCalcKernelI() { } + + //////////////////////////////////////////////////////////////////////////////// + /// Method executes for every data block in the structure. Internal loop over + /// pixels should be placed here. + /// + /// @param[in] p_psImageStructure pointer to images structure, + /// @param[in] p_iCurrentImageID ID number of the current processed image + /// @param[in] p_iFirstRow index of the first row of pixels scheduled for calculation + /// @param[in] p_iRowsCount number of rows scheduled for calculation + //////////////////////////////////////////////////////////////////////////////// + virtual void operator()(mmImageI* p_psCurrentImage, + mmInt p_iFirstRow, + mmInt p_iRowsCount) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface representing calculation method + //////////////////////////////////////////////////////////////////////////////// + class mmCalcMethodI: public mmCalcMethod + { + public: + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. It invokes the mmCalcMethod class constructor which hides + /// implementation details + //////////////////////////////////////////////////////////////////////////////// + mmCalcMethodI(mmLog::mmLogReceiverI *p_psLogReceiver = NULL, + mmString p_sClassName = L"") + :mmCalcMethod(p_psLogReceiver, + p_sClassName) { } + + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmCalcMethodI() { } + + protected: + //////////////////////////////////////////////////////////////////////////////// + /// Method executes for every working thread. Put pixels manipulations code here + //////////////////////////////////////////////////////////////////////////////// + virtual bool Calculate() = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method executes once for every image in the structure before the main loop + /// iterating blocks of pixels when using ForEachImage function. Do not use + /// m_psThreadSynchEL for accessing class members in multithread configuration + /// because this function runs always in a single thread. + /// (check mmICalcMethodExt.h for documentation) + /// + /// @param[in] p_iCurrentImageID ID number of the current processed image + //////////////////////////////////////////////////////////////////////////////// + virtual void ExecBeforeSingleImageCalc(mmInt p_iCurrentImageID) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method executes once for every image in the structure after the main loop + /// iterating blocks of pixels when using ForEachImage function. Do not use + /// m_psThreadSynchEL for accessing class members in multithread configuration + /// because this function runs always in a single thread. + /// (check mmICalcMethodExt.h for documentation) + /// + /// @param[in] p_iCurrentImageID ID number of the current processed image + //////////////////////////////////////////////////////////////////////////////// + virtual void ExecAfterSingleImageCalc(mmInt p_iCurrentImageID) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method executes once before the Calculate method which allows for setting + /// new parameters values after their modification by the user. Place initialization + /// code here. + //////////////////////////////////////////////////////////////////////////////// + virtual void RetrieveParameters() = 0; + }; +}; diff --git a/include/interfaces/mmICalcMethodExt.h b/include/interfaces/mmICalcMethodExt.h new file mode 100644 index 0000000..22e5f16 --- /dev/null +++ b/include/interfaces/mmICalcMethodExt.h @@ -0,0 +1,127 @@ +#pragma once + +#include +#include +#include + +//****************************************************************************** +//****************************************************************************** +// +// Extension for calculation method interface +// +// Description: This header defines class mmCalcMethodExtI which extends +// calculation method interface in order to simplify usage. It contains a set +// of tool functions for parameters manipulation and iteration through data +// structure in multithread environment. These functions are meant to be used +// by developer rather than overload. +// +//****************************************************************************** +//****************************************************************************** + +namespace mmImages { + //////////////////////////////////////////////////////////////////////////////// + /// Forward declaration of mmCalcKernel class + //////////////////////////////////////////////////////////////////////////////// + class mmCalcKernelI; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface representing interface extension for calculation method + //////////////////////////////////////////////////////////////////////////////// + class mmCalcMethodExtI + { + public: + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor + //////////////////////////////////////////////////////////////////////////////// + ~mmCalcMethodExtI() { } + + protected: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Method iterates through data structure in order to perform specified operation + /// on every data block. It works in multithread environment and may be executed + /// by multiple threads to manipulate on the same images structure. It should be + /// used inside Calculate function (see mmICalcMethod.h for documentation) + /// + /// @param[in] p_psKernel pointer to function object which implements operation + /// executed for every data block in every image + //////////////////////////////////////////////////////////////////////////////// + virtual void ForEachImage(mmCalcKernelI* p_psKernel) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method adds new user interface parameter for calculation method + /// + /// @param[in] p_sName parameter name which appears as a label in the parameters + /// dialog box + /// @param[in] p_eType parameter type (see mmXMLIOUtilities.h for documentation) + /// @param[in] p_psValue pointer to variable containing default parameter value + /// @param[in] p_bIsOutput flag indicating if the new parameter is input or + /// output for the calculation method + //////////////////////////////////////////////////////////////////////////////// + virtual void SetParam(mmString p_sName, mmXML::mmXMLDataType p_eType, void* p_psValue, bool p_bIsOutput = false) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method retrieves information about parameter value. + /// + /// @param[in] p_sName parameter name which appears as a label in the parameters + /// dialog box + /// @return pointer to parameter value. It should be assigned to a pointer of + /// the specific type + //////////////////////////////////////////////////////////////////////////////// + virtual const void* GetParam(mmString p_sName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method retrieves information about parameter value. + /// + /// @param[in] p_sName parameter name which appears as a label in the parameters + /// dialog box + /// @param[out] p_pValue pointer to a variable where new parameter value should + /// be stored. It should have proper type. + //////////////////////////////////////////////////////////////////////////////// + virtual void GetParam(mmString p_sName, void* p_pValue) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method creates internal parameters structure. It should be called after all + /// SetParam invocations + //////////////////////////////////////////////////////////////////////////////// + virtual void UpdateParameters() = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns names of all images in the images structure + /// + /// @return vector of image names + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetImageNames() = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns names of all data layers in the images structure + /// + /// @return vector of data layers names + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetDLNames() = 0; + + protected: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Calculation method parameters. Developer should assign the method name, ID as + /// a GUID and indicate if the method should be executed by multiple threads (default) + //////////////////////////////////////////////////////////////////////////////// + mmImages::mmImagesCalculationMethodI::sCalculationMethodParams m_sCMParams; + + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to images structure. Use to access all loaded data. + //////////////////////////////////////////////////////////////////////////////// + mmImages::mmImageStructureI* m_psImageStructure; + + //////////////////////////////////////////////////////////////////////////////// + /// Pointer exclusive lock object. Use to control access to class members in + /// multithread implementation. + //////////////////////////////////////////////////////////////////////////////// + std::tr1::shared_ptr m_psThreadSynchEL; + + //////////////////////////////////////////////////////////////////////////////// + /// Number of rows in single data block. Modify to control amount of data processed + /// by a single thread. The last block may be smaller, depending on image size, + /// because it is a reminder of integer division of image height. + //////////////////////////////////////////////////////////////////////////////// + mmInt m_iRowsCountInBlock; + }; +}; diff --git a/include/interfaces/mmIFileIO.h b/include/interfaces/mmIFileIO.h new file mode 100644 index 0000000..c70dc25 --- /dev/null +++ b/include/interfaces/mmIFileIO.h @@ -0,0 +1,585 @@ +//****************************************************************************** +//****************************************************************************** +// +// FileIO Interface +// +// +// Description: This interface unifies file access/read/write capabilities. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmIFileIOH +#define mmIFileIOH + +#include + +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +/// This namespace unifies Input/Output operations to hard drive resources. +//////////////////////////////////////////////////////////////////////////////// +namespace mmFileIO +{ + //////////////////////////////////////////////////////////////////////////////// + /// This enumeration defines open access to file. + //////////////////////////////////////////////////////////////////////////////// + typedef enum + { + //////////////////////////////////////////////////////////////////////////////// + /// Read access. + //////////////////////////////////////////////////////////////////////////////// + for_read = 0, + //////////////////////////////////////////////////////////////////////////////// + /// Write access. + //////////////////////////////////////////////////////////////////////////////// + trunc_for_write = 1, + //////////////////////////////////////////////////////////////////////////////// + /// Open for write and move to end of file. + //////////////////////////////////////////////////////////////////////////////// + append_for_write = 2 + } eOpenFileMode; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for global methods supports hsrd drive/directories operations. + //////////////////////////////////////////////////////////////////////////////// + class mmFileUtilsI + { + public: // type definitions + //////////////////////////////////////////////////////////////////////////////// + /// Structure defining file/directory on hard drive. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Name of file/directory. + //////////////////////////////////////////////////////////////////////////////// + mmString sName; + //////////////////////////////////////////////////////////////////////////////// + /// TRUE if file, FALSE if directory. + //////////////////////////////////////////////////////////////////////////////// + bool bFile; + } sDirElement; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// This function creates directory. In case of error it throws + /// mmeFileIONoSuchFileOrDirectory, mmeFileIOPermissionToFileDenied or + /// mmeFileIOUnknownError. + /// + /// @param[in] p_sDirName name of directory with path. + //////////////////////////////////////////////////////////////////////////////// + virtual void CreateDir(mmString p_sDirName) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method creates directory(ies) in a given location. + /// + /// @param[in] p_sDirName path to creation. + //////////////////////////////////////////////////////////////////////////////// + virtual void CreateDirStructure(mmString p_sDirName) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// This method deletes all directory content. In case of error it throws + /// mmeFileIONoSuchFileOrDirectory, mmeFileIOPermissionToFileDenied or + /// mmeFileIOUnknownError. + /// + /// @param[in] p_sDirName directory name with path. + //////////////////////////////////////////////////////////////////////////////// + virtual void ClearDir(mmString p_sDirName) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// This method deletes directory. In case of error it throws + /// mmeFileIONoSuchFileOrDirectory, mmeFileIOPermissionToFileDenied or + /// mmeFileIOUnknownError. + /// + /// @param[in] p_sDirName directory name with path, + /// @param[in] p_bWithElements if TRUE it deletes also directory content, + /// if FALSE deletes only if directory is empty. + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveDir(mmString p_sDirName,bool p_bWithElements) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method checks if given directory exists. In case of error it throws + /// mmeFileIOUnknownError. + /// + /// @param[in] p_sDirName directory name with full path, + /// @return if directory exists it returns TRUE, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsExistingDir(mmString p_sDirName) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method returns path do temporary directory. In case of error it throws + /// mmeFileIONoTemporaryDirectory. + /// + /// @return full path to temporary directory + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetTemporaryDir(void) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// This method returns full path to application directory. + /// + /// @return full path to application + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetApplicationDir(void) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method returns elements belonging to directory p_sDirName. + /// + /// @param[in] p_sDirName full path to directory + /// @param[in] p_sDirWildcards string defining search criterion eg "*.txt" or + /// "*.*", + /// @return vector with directory elements. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetDirElements(mmString p_sDirName, + mmString p_sDirWildcards) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method checks if given directory is empty or not. + /// + /// @param[in] p_sDirName full path to directory, + /// @return TRUE if directory is empty, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsEmptyDir(mmString p_sDirName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method removes file from hard drive. In case of error it throws + /// mmeFileIONoSuchFileOrDirectory, mmeFileIOPermissionToFileDenied or + /// mmeFileIOUnknownError. + /// + /// @param[in] p_sFileName name with full path of file to remove + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveFile(mmString p_sFileName) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// This method checks if file exists. + /// + /// @param[in] p_sFileName name with full path to checked file + /// @return TRUE if file exists, FALSE otherwise + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsExistingFile(mmString p_sFileName) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method extracts path to file from full path with name. + /// + /// @param[in] p_sFileName file name with full path, + /// @return path to file. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetPathToFile(mmString p_sFileName) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for text file reading functionality. + //////////////////////////////////////////////////////////////////////////////// + class mmTextFileReadI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual desctructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmTextFileReadI() {}; + public: // methods + + //////////////////////////////////////////////////////////////////////////////// + /// Method opens file for reading. In case of error during file opening + /// it throws mmError(mmeFileIOCantOpenFile) + /// + /// @param[in] p_sFileName file name with full path to open. + //////////////////////////////////////////////////////////////////////////////// + virtual void Open(mmString p_sFileName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method closes opened file. + //////////////////////////////////////////////////////////////////////////////// + virtual void Close(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method reads and returns char from file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). In case of read error it throws + /// mmError(mmeFileIOCantReadFromFile). + /// + /// @param[out] p_pcChar red char is stored here + /// @return TRUE if read successful, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool ReadChar(wchar_t* p_pcChar) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method reads and return line from file. If file position is in the middle + /// line it returns only rest of line. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). In case of read error it throws + /// mmError(mmeFileIOCantReadFromFile). + /// + /// @param[out] p_psFileLine red line is stored here + /// @return TRUE if read successful, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool ReadLine(mmString* p_psFileLine) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method reads many lines from file. + /// + /// @param[out] p_psLines pointer to vector of strings where red lines are stored + /// @param[in] p_iLinesCount number of lines to read + /// @return number of really red lines, if =0 end of file or error occurs + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt ReadLines(std::vector* p_psLines,mmInt p_iLinesCount) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns size of opened file in bytes. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return size of file. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetLenght(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method reads whole file and stores it in memory pointed by p_pcFileContent. + /// p_pcFileContent memory block should be large enough to store file content. + /// If file is not opened it throws mmError(mmeFileIOFileIsNotOpened). + /// In case of read error it throws mmError(mmeFileIOCantReadFromFile). + /// + /// @param[out] p_pcFileContent pointer to memory block where file content is stored + /// @return number of really readed chars. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt ReadWholeFile(wchar_t* p_pcFileContent) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method checks end of file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). In case of read error it throws + /// mmError(mmeFileIOCantReadFromFile). + /// + /// @return TRUE if end of file, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool Eof(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns information if any file is opened currently. + /// + /// @return TRUE if file is already opened, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsActiveFile(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns current file position. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return current file position. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetActualFilePosition(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns name of opened file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return file name. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetFileName(void) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for text file reading functionality with extension of reading of + /// whole file into memory during opening and further use of data from memory + /// only. + //////////////////////////////////////////////////////////////////////////////// + class mmMemTextFileReadI: public mmTextFileReadI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmMemTextFileReadI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method opens text file for reading. In case of error during file opening + /// it throws mmError(mmeFileIOCantOpenFile). In case of read error it throws + /// mmError(mmeFileIOCantReadFromFile). + /// + /// @param[in] p_sFileName file name with path + /// @param[in] p_bToMemory TRUE it reads whole file into memory, FALSE it opens + /// file in standard way + //////////////////////////////////////////////////////////////////////////////// + virtual void Open(mmString p_sFileName,bool p_bToMemory) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for text file writing functionality. + //////////////////////////////////////////////////////////////////////////////// + class mmTextFileWriteI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmTextFileWriteI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method opens file for writing. In case of error during file opening + /// it throws mmError(mmeFileIOCantOpenFile). + /// + /// @param[in] p_sFileName file name with full path + /// @param[in] p_eOpenMode file open mode + //////////////////////////////////////////////////////////////////////////////// + virtual void Open(mmString p_sFileName, + mmFileIO::eOpenFileMode p_eOpenMode) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method closes opened file. It saves all unsaved data. + /// In case of write error throws mmError(mmeFileIOCantWriteToFile). + //////////////////////////////////////////////////////////////////////////////// + virtual void Close(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method writes char to file. In case of write error throws + /// mmError(mmeFileIOCantWriteToFile). If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @param[in] p_cChar char to write + //////////////////////////////////////////////////////////////////////////////// + virtual void WriteChar(wchar_t p_cChar) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method writes line to file. In case of write error throws + /// mmError(mmeFileIOCantWriteToFile). If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @param[in] p_sFileLine string to write line + //////////////////////////////////////////////////////////////////////////////// + virtual void WriteLine(mmString p_sFileLine) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Mehtod writes many lines to file. + /// + /// @param[in] p_psLines pointer to vector of strings representing lines to write. + //////////////////////////////////////////////////////////////////////////////// + virtual void WriteLines(std::vector* p_psLines) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method writes text buffer into file. In case of write error throws + /// mmError(mmeFileIOCantWriteToFile). If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @param[in] p_pcBuffer pointer to text buffer to write + /// @param[in] p_iBufferSize size of buffer + //////////////////////////////////////////////////////////////////////////////// + virtual void WriteBuffer(wchar_t const* p_pcBuffer,mmInt p_iBufferSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method writes end of line command into file. In case of write error throws + /// mmError(mmeFileIOCantWriteToFile). If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + //////////////////////////////////////////////////////////////////////////////// + virtual void WriteEol(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method flushes file buffers and forces writing of all data. + /// In case of write error throws mmError(mmeFileIOCantWriteToFile). + /// If file is not opened it throws mmError(mmeFileIOFileIsNotOpened). + //////////////////////////////////////////////////////////////////////////////// + virtual void Flush(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method checks if object uses (keep opened) currently any file. + /// + /// @return TRUE file is using, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsActiveFile(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method returns name of currently opened file. + /// If file is not opened it throws mmError(mmeFileIOFileIsNotOpened). + /// + /// @return file name with full path. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetFileName(void) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for text file writing functionality with extension of writing of + /// whole file into memory and at the end saving whole memory structure into file. + //////////////////////////////////////////////////////////////////////////////// + class mmMemTextFileWriteI: public mmTextFileWriteI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmMemTextFileWriteI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method opens text fole to write. In case of error during file opening + /// it throws mmError(mmeFileIOCantOpenFile). + /// + /// @param[in] p_sFileName file name with full path to write + /// @param[in] p_eOpenMode file open mode + /// @param[in] p_bToMemory TRUE it creates whole file into memory and writes + /// it on hard drive once, FALSE it opens file + /// for write in standard way. + //////////////////////////////////////////////////////////////////////////////// + virtual void Open(mmString p_sFileName, + eOpenFileMode p_eOpenMode, + bool p_bToMemory) = 0; + + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for binary file reading functionality. + //////////////////////////////////////////////////////////////////////////////// + class mmBinaryFileReadI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual desctructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmBinaryFileReadI() {}; + public: // methods + + //////////////////////////////////////////////////////////////////////////////// + /// Method opens file for reading. In case of error during file opening + /// it throws mmError(mmeFileIOCantOpenFile) + /// + /// @param[in] p_sFileName file name with full path to open. + //////////////////////////////////////////////////////////////////////////////// + virtual void Open(mmString p_sFileName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method closes opened file. + //////////////////////////////////////////////////////////////////////////////// + virtual void Close(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method reads buffer from file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). In case of read error it throws + /// mmError(mmeFileIOCantReadFromFile). + /// + /// @param[out] p_pBuffer red buffer is stored here + /// @param[in] p_iSize number of bytes to read from file + /// @return TRUE if read successful, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool ReadBuffer(void* p_pBuffer,mmInt p_iSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns size of opened file in bytes. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return size of file. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetLenght(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method checks end of file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). In case of read error it throws + /// mmError(mmeFileIOCantReadFromFile). + /// + /// @return TRUE if end of file, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool Eof(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns information if any file is opened currently. + /// + /// @return TRUE if file is already opened, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsActiveFile(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns current file position. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return current file position. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetActualFilePosition(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets current file position. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened) or mmError(mmeFileIOBadFilePosition). + /// + /// @param[in] p_iFilePos requested file position + /// @return current file position. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetActualFilePosition(mmInt p_iFilePos) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns name of opened file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return file name. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetFileName(void) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for binary file writing functionality. + //////////////////////////////////////////////////////////////////////////////// + class mmBinaryFileWriteI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual desctructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmBinaryFileWriteI() {}; + public: // methods + + //////////////////////////////////////////////////////////////////////////////// + /// Method opens file for writing. In case of error during file opening + /// it throws mmError(mmeFileIOCantOpenFile). + /// + /// @param[in] p_sFileName file name with full path + /// @param[in] p_eOpenMode file open mode + //////////////////////////////////////////////////////////////////////////////// + virtual void Open(mmString p_sFileName, + mmFileIO::eOpenFileMode p_eOpenMode) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method closes opened file. + //////////////////////////////////////////////////////////////////////////////// + virtual void Close(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves buffer into file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). In case of write error it throws + /// mmError(mmeFileIOCantWriteToFile). + /// + /// @param[out] p_pBuffer pointer to buffer + /// @param[in] p_iSize number of bytes to write into file + /// @return TRUE if read successful, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool WriteBuffer(void* p_pBuffer,mmInt p_iSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns size of opened file in bytes. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return size of file. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetLenght(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns information if any file is opened currently. + /// + /// @return TRUE if file is already opened, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsActiveFile(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns current file position. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return current file position. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetActualFilePosition(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets current file position. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened) or mmError(mmeFileIOBadFilePosition). + /// + /// @param[in] p_iFilePos requested file position + /// @return current file position. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetActualFilePosition(mmInt p_iFilePos) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns name of opened file. If file is not opened it throws + /// mmError(mmeFileIOFileIsNotOpened). + /// + /// @return file name. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetFileName(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method flushes file buffers and forces writing of all data. + /// In case of write error throws mmError(mmeFileIOCantWriteToFile). + /// If file is not opened it throws mmError(mmeFileIOFileIsNotOpened). + //////////////////////////////////////////////////////////////////////////////// + virtual void Flush(void) = 0; + }; +}; + +#endif diff --git a/include/interfaces/mmIHardware.h b/include/interfaces/mmIHardware.h new file mode 100644 index 0000000..1018d4a --- /dev/null +++ b/include/interfaces/mmIHardware.h @@ -0,0 +1,789 @@ +//****************************************************************************** +//****************************************************************************** +// +// Hardware component interfaces +// +// +// Description: This header defines interfaces for hardware components like +// detectors, projectors, linear stages, rotary stages, robots, etc. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmIHardwareH +#define mmIHardwareH + +#include +#include +#include +#include +#include + +namespace mmImageProcessing +{ + //////////////////////////////////////////////////////////////////////////////// + /// Enumeration for definition of pixel color packing. + //////////////////////////////////////////////////////////////////////////////// + typedef enum + { + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by by 3 bytes Red, Green and Blue. + //////////////////////////////////////////////////////////////////////////////// + pixel_R8G8B8 = 0x00000000, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by by 3 bytes Blue, Green and Red. + //////////////////////////////////////////////////////////////////////////////// + pixel_B8G8R8 = 0x00000001, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by one grayscale intensity byte value. + //////////////////////////////////////////////////////////////////////////////// + pixel_Gray8 = 0x00000002, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by 16bit grayscale intensity value. + //////////////////////////////////////////////////////////////////////////////// + pixel_Gray16 = 0x00000003, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by 3 16bit values Red, Green and Blue. (Deep color) + //////////////////////////////////////////////////////////////////////////////// + pixel_R16G16B16 = 0x00000004, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by by 4 bytes Red, Green, Blue and Alpha + //////////////////////////////////////////////////////////////////////////////// + pixel_R8G8B8A8 = 0x00000005, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel is represented by by 4 bytes Blue, Green, Red and Alpha + //////////////////////////////////////////////////////////////////////////////// + pixel_B8G8R8A8 = 0x00000006, + //////////////////////////////////////////////////////////////////////////////// + /// Pixel format irrelevant, doesn't matter or undefined + //////////////////////////////////////////////////////////////////////////////// + pixel_AnyType = -1 + //////////////////////////////////////////////////////////////////////////////// + } ePixelType; + + mmInt GetPixelSize(mmImageProcessing::ePixelType p_ePixelType); +} + +//////////////////////////////////////////////////////////////////////////////// +/// This namespace defines functionality of basic hardware components +/// like detector, projector, linear and rotary stages, robot, etc. +//////////////////////////////////////////////////////////////////////////////// +namespace mmHardware +{ + //////////////////////////////////////////////////////////////////////////////// + /// Structure defines raw image data packing for hardware operations. + //////////////////////////////////////////////////////////////////////////////// + + // //////////////////// ??????? + + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Image width. + //////////////////////////////////////////////////////////////////////////////// + mmInt iWidth; + //////////////////////////////////////////////////////////////////////////////// + /// Image height. + //////////////////////////////////////////////////////////////////////////////// + mmInt iHeight; + //////////////////////////////////////////////////////////////////////////////// + /// Pixel packing. + //////////////////////////////////////////////////////////////////////////////// + mmImageProcessing::ePixelType ePixType; + } sImageDef; + + //////////////////////////////////////////////////////////////////////////////// + /// Mechanical manipulator interface. + //////////////////////////////////////////////////////////////////////////////// + class mmManipulatorI + { + public: + //////////////////////////////////////////////////////////////////////////////// + /// Definition of manipulator status enum. + //////////////////////////////////////////////////////////////////////////////// + enum mmManipulatorStatus + { + //////////////////////////////////////////////////////////////////////////////// + /// Manipulator axis is stopped. + //////////////////////////////////////////////////////////////////////////////// + mmmsStopped = 0, + //////////////////////////////////////////////////////////////////////////////// + /// Manipulator axis is moving. + //////////////////////////////////////////////////////////////////////////////// + mmmsMoving = 1, + //////////////////////////////////////////////////////////////////////////////// + /// Manipulator axis is blocked. + //////////////////////////////////////////////////////////////////////////////// + mmmsBlocked = 2, + //////////////////////////////////////////////////////////////////////////////// + /// Manipulator axis is disconnected. + //////////////////////////////////////////////////////////////////////////////// + mmmsDisconected = 3, + //////////////////////////////////////////////////////////////////////////////// + /// Manipulator axis status is unknown. + //////////////////////////////////////////////////////////////////////////////// + mmmsUnknown = 4 + + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmManipulatorI(void) {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method initializes manipulator. LoadManipulatorGlobalParameters() or + /// SetManipulatorGlobalParameters() has to be done before calling + /// InitializeManipulator().If manipulator is not initialized, it can't moved. + /// + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL InitializeManipulator(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method synchronizes manipulator driver. Synchronization is automatically + /// done in InitializeManipulator() method. + /// + /// @param[in] p_uiRepeatCount how many times method tries to synchronize driver, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL Synchronize(unsigned int p_uiRepeatCount = 40) {return FALSE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with manipulator axis parameters. + /// + /// @param[in] p_uiAxisNumber number of manipulator axis, + /// @return XML structure with manipulator axis parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetManipulatorParameters(unsigned int p_uiAxisNumber = 1) {return NULL;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets manipulator axis parameters. + /// + /// @param[in] p_sAxisParameters XML structure withm anipulator axis parameters, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL SetManipulatorParameters(mmString p_sAxisParameters, + unsigned int p_uiAxisNumber = 1) {return FALSE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method loads manipulator parameters from XML file. + /// + /// @param[in] p_sFilePath path to file with manipulator parameters XML structure, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL LoadManipulatorGlobalParameters(mmString p_sFilePath) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with manipulator parameters. + /// + /// @return XML structure with manipulator axis parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetManipulatorGlobalParameters(void) {return NULL;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets manipulator parameters. + /// + /// @param[in] p_sManipulatorGlobalParameters XML structure with manipulator parameters, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL SetManipulatorGlobalParameters(mmString p_sManipulatorGlobalParameters) {return FALSE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves XML structure with manipulator parameters to file. + /// + /// @param[in] p_sFilePath path to file, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL SaveManipulatorGlobalParameters(mmString p_sFilePath) {return FALSE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method loads manipulator state from XML file. + /// + /// @param[in] p_sFilePath path to file with manipulator state XML structure, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL LoadManipulatorGlobalState(mmString p_sFilePath) {return FALSE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves XML structure with manipulator state to file. + /// + /// @param[in] p_sFilePath path to file, + /// @return TRUE if no error occured, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL SaveManipulatorGlobalState(mmString p_sFilePath) {return FALSE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns number of manipulator axes. + /// + /// @return number of manipulator axes. + //////////////////////////////////////////////////////////////////////////////// + virtual unsigned int GetManipulatorAxisCount(void) {return 0;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns working mode of an axis of manipulator. Active means that it + /// can be manipulated. Passive that it can only return actual transformations, + /// all movements are performed out of control of application. + /// + /// @param[in] p_uiAxisNumber axis number, + /// @return TRUE if it can't be controllable, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual BOOL IsPassive(unsigned int p_uiAxisNumber = 1) {return TRUE;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns status of manipulator axis. + /// + /// @param[in] p_uiAxisNumber axis number, + /// @return status of manipulator axis. + //////////////////////////////////////////////////////////////////////////////// + virtual mmManipulatorStatus GetManipulatorStatus(unsigned int p_uiAxisNumber = 1) {return mmmsUnknown;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns position of manipulator axis. + /// + /// @param[in] p_uiAxisNumber axis number, + /// @return position of manipulator axis. + //////////////////////////////////////////////////////////////////////////////// + virtual mmReal GetPosition(unsigned int p_uiAxisNumber = 1) {return 0.0;}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method realizes manipulation of manipulator axis. + /// + /// @param[in] p_rValue manipulation value in units appropriate for axis type, + /// @param[in] p_uiAxisNumber axis number, + /// @return real manipulation value. + //////////////////////////////////////////////////////////////////////////////// + virtual mmReal Move(mmReal p_rValue, unsigned int p_uiAxisNumber = 1) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method realizes emergency stop of all axes of manipulator. + //////////////////////////////////////////////////////////////////////////////// + virtual void EmergencyStop(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method realizes user action. + /// + /// @param[in] p_sUserAction XML structure with user action command, + /// @return XML structure with manipulator reply. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString UserAction(mmString p_sUserAction) {return NULL;}; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Manipulator container interface. It is responsible for + /// searching all available manipulators and querying them. It also initializes + /// manipulator objects and return pointers to them. + //////////////////////////////////////////////////////////////////////////////// + class mmManipulatorContainerI + { + public: // name + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmManipulatorContainerI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Returns list with names of available manipulators. + /// + /// @return vector with names defining available manipulators. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetAvailableManipulators(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes selected manipulator and returns pointer into its interface. + /// In case of error it throws mmError(mmeHardwareUnknownManipulator). + /// + /// @param[in] p_sManipulatorName name of manipulator to initialize, + /// @return pointer to initialized mmHardware::mmManipulatorI object. + //////////////////////////////////////////////////////////////////////////////// + virtual mmHardware::mmManipulatorI* InitializeManipulator(mmString p_sManipulatorName) = 0; + }; + + + //////////////////////////////////////////////////////////////////////////////// + /// Detector interface. + //////////////////////////////////////////////////////////////////////////////// + class mmDetectorI + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// ID name of detector. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sName; + protected: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Method sets name of detector. + /// + /// @param[in] p_sName detector name + //////////////////////////////////////////////////////////////////////////////// + void SetName(mmString p_sName) + { + m_sName = p_sName; + }; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmDetectorI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns name of detector. + /// + /// @return name of detector + //////////////////////////////////////////////////////////////////////////////// + const wchar_t* GetName(void) + { + return m_sName.c_str(); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with global params of detector. These params + /// are used globally, they are not changing from image to image. + /// + /// @return XML structure with global parameters + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetXMLGlobalParams(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with global params of detector. These params + /// are used globally, they are not changing from image to image. + /// + /// @param[in] p_pcXMLParamsBuffer buffer with XML structure with global parameters + /// @param[in] p_iXMLParamsBufferSize size of buffer + //////////////////////////////////////////////////////////////////////////////// + virtual void GetXMLGlobalParams( wchar_t* p_pcXMLParamsBuffer, + mmInt p_iXMLParamsBufferSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new set of global params for detector. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_sXMLParams XML definition of global detector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLGlobalParams(mmString p_sXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new set of global params for detector. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_pcXMLParams XML definition of global detector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLGlobalParams(wchar_t* p_pcXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with image parameters. These parameters can be + /// changed from image to image. + /// + /// @return XML structure with image parameters + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetXMLImageParams(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with image parameters. These parameters can be + /// changed from image to image. + /// + /// @param[in] p_pcXMLParamsBuffer buffer with XML structure with image parameters + /// @param[in] p_iXMLParamsBufferSize size of buffer + //////////////////////////////////////////////////////////////////////////////// + virtual void GetXMLImageParams( wchar_t* p_pcXMLParamsBuffer, + mmInt p_iXMLParamsBufferSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new set of local params for detector. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_sXMLParams XML definition of local detector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLImageParams(mmString p_sXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new set of local params for detector. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_pcXMLParams XML definition of local detector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLImageParams(wchar_t* p_pcXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method captures image from detector. In case of error it throws + /// mmError(mmeHardwareCantCapture). + //////////////////////////////////////////////////////////////////////////////// + virtual void CaptureImage(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns captured image count. + /// + /// @return count of captured image. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetCapturedImagesCount(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns info about previously captured image. In case of error + /// it throws mmError(mmeHardwareImageOutOfRange). + /// + /// @param[in] p_iImageIndex index of requested image + /// @return information about image + //////////////////////////////////////////////////////////////////////////////// + virtual sImageDef GetImageInfo(mmInt p_iImageIndex) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns previously captured image. In case of error it throws + /// mmError(mmeHardwareImageOutOfRange). + /// + /// @param[in] p_iImageIndex index of requested image + /// @param[in] p_psImageData pointer where image data have to be copied. + //////////////////////////////////////////////////////////////////////////////// + virtual void GetImageData( mmInt p_iImageIndex, + void* p_psImageData) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method deletes all images stored in detector memory. + //////////////////////////////////////////////////////////////////////////////// + virtual void DeleteAllImages(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns info about flash state. + /// + /// @return TRUE if flash function is enabled, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsFlashOn(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets flash state. + /// + /// @param[in] p_bFlashOnOff new flash state + //////////////////////////////////////////////////////////////////////////////// + virtual void SetFlash(bool p_bFlashOnOff) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves detector state into XML file. It not save images. + /// + /// @param[in] p_sPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void SaveStateInXMLFile(mmString p_sPathToFile) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves detector state into XML file. It not save images. + /// + /// @param[in] p_pcPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void SaveStateInXMLFile(wchar_t* p_pcPathToFile) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method loads detector state from XML file. + /// + /// @param[in] p_sPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void LoadStateFromXMLFile(mmString p_sPathToFile) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method loads detector state from XML file. + /// + /// @param[in] p_pcPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void LoadStateFromXMLFile(wchar_t* p_pcPathToFile) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Detector container interface. It is responsible for + /// searching all available detectors and querying them. It also initializes + /// detector objects and return pointers to them. + //////////////////////////////////////////////////////////////////////////////// + class mmDetectorContainerI + { + public: // name + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmDetectorContainerI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Returns list with names of available detectors. + /// + /// @return vector with names defining available detectors. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetAvailableDetectors(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes selected detector and returns pointer into its interface. + /// In case of error it throws mmError(mmeHardwareUnknownDetector). + /// + /// @param[in] p_sDetectorName name of detector to initialize, + /// @return pointer to initialized mmHardware::mmDetectorI object. + //////////////////////////////////////////////////////////////////////////////// + virtual mmHardware::mmDetectorI* InitializeDetector(mmString p_sDetectorName) = 0; + }; + + + + //////////////////////////////////////////////////////////////////////////////// + /// Projector interface. + //////////////////////////////////////////////////////////////////////////////// + class mmProjectorI + { + public: // definitions + //////////////////////////////////////////////////////////////////////////////// + /// Definition of projected image type. + //////////////////////////////////////////////////////////////////////////////// + typedef enum + { + //////////////////////////////////////////////////////////////////////////////// + /// Image with constant intensity (image is defined by one pixel value). + //////////////////////////////////////////////////////////////////////////////// + constant_intensity = 0, + //////////////////////////////////////////////////////////////////////////////// + /// Image with horizontal orientation (image is defined by one row). + //////////////////////////////////////////////////////////////////////////////// + horizontal_orientation = 1, + //////////////////////////////////////////////////////////////////////////////// + /// Image with vertical orientation (image is defined by one column). + //////////////////////////////////////////////////////////////////////////////// + vertical_orientation = 2, + //////////////////////////////////////////////////////////////////////////////// + /// Image with horizontal orientation (image is defined by one row). + //////////////////////////////////////////////////////////////////////////////// + horizontal_and_vertical_orientation = 3, + //////////////////////////////////////////////////////////////////////////////// + /// Two-dimensional image (each pixel of image is defined). + //////////////////////////////////////////////////////////////////////////////// + image2D = 4 + } eProjectorImageType; + //////////////////////////////////////////////////////////////////////////////// + /// Definition of projector image. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Image type. + //////////////////////////////////////////////////////////////////////////////// + eProjectorImageType eImageType; + //////////////////////////////////////////////////////////////////////////////// + /// Red intensities. + //////////////////////////////////////////////////////////////////////////////// + std::vector vRed; + //////////////////////////////////////////////////////////////////////////////// + /// Green intensities. + //////////////////////////////////////////////////////////////////////////////// + std::vector vGreen; + //////////////////////////////////////////////////////////////////////////////// + /// Blue intensities. + //////////////////////////////////////////////////////////////////////////////// + std::vector vBlue; + //////////////////////////////////////////////////////////////////////////////// + /// Defines if quality of measurement will increase if this image will be + /// reperated and further averaged. + //////////////////////////////////////////////////////////////////////////////// + bool bIsRepeatable; + } sProjectorImageDef; + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// ID name of projector. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sName; + protected: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Method sets name of projector. + /// + /// @param[in] p_sName projector name + //////////////////////////////////////////////////////////////////////////////// + void SetName(mmString p_sName) + { + m_sName = p_sName; + }; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmProjectorI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns name of projector. + /// + /// @return name of projector + //////////////////////////////////////////////////////////////////////////////// + const wchar_t* GetName(void) + { + return m_sName.c_str(); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with global params of projector. These params + /// are used globally, they are not changing from image to image projected. + /// + /// @return XML structure with global parameters + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetXMLGlobalParams(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with global params of projector. These params + /// are used globally, they are not changing from image to image projected. + /// + /// @param[in] p_pcXMLParamsBuffer buffer with XML structure with global parameters + /// @param[in] p_iXMLParamsBufferSize size of buffer + //////////////////////////////////////////////////////////////////////////////// + virtual void GetXMLGlobalParams(wchar_t* p_pcXMLParamsBuffer, + mmInt p_iXMLParamsBufferSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new set of global params for projector. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_sXMLParams XML definition of global projector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLGlobalParams(mmString p_sXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new set of global params for projector. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_pcXMLParams XML definition of global projector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLGlobalParams(wchar_t* p_pcXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with projected image parameters. These + /// parameters can be changed from image to image projected. + /// + /// @return XML structure with projected image parameters + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetXMLImageParams(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns XML structure with projected image parameters. These + /// parameters can be changed from image to image projected. + /// + /// @param[in] p_pcXMLParamsBuffer buffer with XML structure with image parameters + /// @param[in] p_iXMLParamsBufferSize size of buffer + //////////////////////////////////////////////////////////////////////////////// + virtual void GetXMLImageParams(wchar_t* p_pcXMLParamsBuffer, + mmInt p_iXMLParamsBufferSize) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new values of projected image. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_sXMLParams XML definition of local projector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLImageParams(mmString p_sXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new values of projected image. In case of error + /// it throws mmError(mmeHardwareBadInputParams) and + /// mmError(mmeHardwareBadRangeForParamsValue). + /// + /// @param[in] p_pcXMLParams XML definition of local projector parameters. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetXMLImageParams(wchar_t* p_pcXMLParams) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method initialises image sequence to project. + /// + /// @param[in] p_psProjImages pointer to vector storing image sequence definition + //////////////////////////////////////////////////////////////////////////////// + virtual void InitializeImageSequence(std::vector* p_psProjImages) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method returns count of initialized image sequence. + /// + /// @return count of initialized image sequence + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetInitializedImageSequenceCount(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method starts rendering process. In case of error + /// it throws mmError(mmeHardwareInitialisationError). + //////////////////////////////////////////////////////////////////////////////// + virtual void StartProjectionMode(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method stops rendering process. + //////////////////////////////////////////////////////////////////////////////// + virtual void StopProjectionMode(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method projects image from image sequence list. + /// + /// @param[in] m_iImageIndex index of image in sequence list. + //////////////////////////////////////////////////////////////////////////////// + virtual void ProjectImage(mmInt m_iImageIndex) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns projection width. + /// + /// @return projection width. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetProjectionWidth(void) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method returns projection height. + /// + /// @return projection height. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetProjectionHeight(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves projector state into XML file. It not save image sequence. + /// + /// @param[in] p_sPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void SaveStateInXMLFile(mmString p_sPathToFile) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves projector state into XML file. It not save image sequence. + /// + /// @param[in] p_pcPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void SaveStateInXMLFile(wchar_t* p_pcPathToFile) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method loads projector state from XML file. + /// + /// @param[in] p_sPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void LoadStateFromXMLFile(mmString p_sPathToFile) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method loads projector state from XML file. + /// + /// @param[in] p_pcPathToFile path to XML file. + //////////////////////////////////////////////////////////////////////////////// + virtual void LoadStateFromXMLFile(wchar_t* p_pcPathToFile) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Projector container interface. It is responsible for + /// searching all available projectors and querying them. It also initializes + /// projector objects and return pointers to them. + //////////////////////////////////////////////////////////////////////////////// + class mmProjectorContainerI + { + public: // name + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmProjectorContainerI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Returns list with names of available projectors. + /// + /// @return vector with names defining available projectors. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetAvailableProjectors(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes selected projector and returns pointer into its interface. + /// In case of error it throws mmError(mmeHardwareUnknownDetector). + /// + /// @param[in] p_sProjectorName name of projector to initialize, + /// @return pointer to initialized mmHardware::mmProjectorI object. + //////////////////////////////////////////////////////////////////////////////// + virtual mmHardware::mmProjectorI* InitializeProjector(mmString p_sProjectorName) = 0; + }; +}; + +#endif diff --git a/include/interfaces/mmIImages.h b/include/interfaces/mmIImages.h new file mode 100644 index 0000000..c7bea71 --- /dev/null +++ b/include/interfaces/mmIImages.h @@ -0,0 +1,287 @@ +//****************************************************************************** +//****************************************************************************** +// +// Images interfaces +// +// Description: This header defines mmImages namespace and its main interfaces. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmIImagesInterfacesH +#define mmIImagesInterfacesH + +#include +#include +#include +#include + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// It defines size of input/output XML params definition for calculation +/// automation. +//////////////////////////////////////////////////////////////////////////////// +#define INOUT_PARAMS_SIZE 4096 + +//////////////////////////////////////////////////////////////////////////////// +/// Namespace for images storage, calculation and manipulation. +//////////////////////////////////////////////////////////////////////////////// +namespace mmImages +{ + class mmLayerI; + class mmImageI; + class mmImageStructureI; + + class mmStats { + public: + mmStats(void); + void Clear(void); + void Update(mmReal const p_prValues[], mmUInt const p_iSize); + public: + static mmReal const rInvalid; + public: + mmReal rMin; + mmReal rMax; + mmReal rAverage; + mmReal rStdDev; + }; + + class mmLayerI { + public: + class mmCallbackI { + public: + virtual void OnLayerCreate(mmLayerI * p_psLayer) = 0; + virtual void OnLayerDestroy(mmLayerI * p_psLayer) = 0; + virtual void OnLayerPropertiesChange(mmLayerI * p_psLayer) = 0; + virtual void OnLayerValuesChange(mmLayerI * p_psLayer) = 0; + }; + public: + static mmUInt const iInvalid; + public: + virtual mmUInt GetWidth(void) const = 0; + virtual mmUInt GetHeight(void) const = 0; + virtual mmReal GetDefaultValue(void) const = 0; + + virtual mmStats GetStats(void) const = 0; + + virtual mmString GetName(void) const = 0; + virtual void SetName(mmString const & p_sName) = 0; + + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmReal p_prValues[]) const = 0; + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmReal const p_prValues[]) = 0; + + virtual bool GetPixels(mmRect const & p_sRect, mmReal p_prValues[]) const = 0; + virtual bool SetPixels(mmRect const & p_sRect, mmReal const p_prValues[]) = 0; + + virtual ~mmLayerI(void) {}; + }; + + class mmImageI { + public: + class mmCallbackI { + public: + virtual void OnImageCreate(mmImageI * p_psImage) = 0; + virtual void OnImageDestroy(mmImageI * p_psImage) = 0; + virtual void OnImagePropertiesChange(mmImageI * p_psImage) = 0; + virtual void OnImagePixelsChange(mmImageI * p_psImage) = 0; + virtual void OnLayerCreate(mmImageI * p_psImage, mmLayerI * p_psLayer) = 0; + virtual void OnLayerDestroy(mmImageI * p_psImage, mmLayerI * p_psLayer) = 0; + virtual void OnLayerPropertiesChange(mmImageI * p_psImage, mmLayerI * p_psLayer) = 0; + virtual void OnLayerValuesChange(mmImageI * p_psImage, mmLayerI * p_psLayer) = 0; + }; + public: + enum mmPixelType {mmP8=1, mmP24=3, mmP32=4}; + public: + static mmUInt const iInvalid; + public: + virtual mmUInt GetWidth(void) const = 0; + virtual mmUInt GetHeight(void) const = 0; + virtual void Resize(mmUInt const p_iWidth, mmUInt const p_iHeight) = 0; + + virtual mmPixelType GetPixelType(void) const = 0; + + virtual mmString GetName(void) const = 0; + virtual void SetName(mmString const & p_sName) = 0; + + virtual mmLayerI * GetChannel(mmUInt const p_iIndex) const = 0; + + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel8 p_psValues[]) const = 0; + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel24 p_psValues[]) const = 0; + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel32 p_psValues[]) const = 0; + + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel8 const p_psValues[]) = 0; + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel24 const p_psValues[]) = 0; + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel32 const p_psValues[]) = 0; + + virtual bool GetPixels(mmRect const & p_sRect, mmPixel8 p_psValues[]) const = 0; + virtual bool GetPixels(mmRect const & p_sRect, mmPixel24 p_psValues[]) const = 0; + virtual bool GetPixels(mmRect const & p_sRect, mmPixel32 p_psValues[]) const = 0; + + virtual bool SetPixels(mmRect const & p_sRect, mmPixel8 const p_psValues[]) = 0; + virtual bool SetPixels(mmRect const & p_sRect, mmPixel24 const p_psValues[]) = 0; + virtual bool SetPixels(mmRect const & p_sRect, mmPixel32 const p_psValues[]) = 0; + + virtual void SetRegionOfInterest(mmRect const & p_sRegion) = 0; + virtual mmRect GetRegionOfInterest(void) const = 0; + + virtual mmUInt CreateLayer(mmString const & p_sName, mmReal const p_rDefaultValue) = 0; + virtual mmUInt GetLayerCount(void) const = 0; + virtual mmLayerI * GetLayer(mmUInt const p_iIndex) const = 0; + virtual mmLayerI * GetLayer(mmString const & p_sName) const = 0; + virtual bool DeleteLayer(mmUInt const p_iIndex) = 0; + virtual bool DeleteLayer(mmString const & p_sName) = 0; + + virtual void SetMetadata(mmString const & p_sMetadata) = 0; + virtual mmString GetMetadata(void) = 0; + + virtual ~mmImageI(void) {}; + }; + + class mmImageStructureI { + public: + virtual mmUInt CreateImage(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmImageI::mmPixelType const p_ePixelType) = 0; + virtual mmUInt GetImageCount(void) const = 0; + virtual mmImageI * GetImage(mmUInt const p_iIndex) const = 0; + virtual mmImageI * GetImage(mmString const & p_sName) const = 0; + virtual bool DeleteImage(mmUInt const p_iIndex) = 0; + virtual bool DeleteImage(mmString const & p_sName) = 0; + + virtual ~mmImageStructureI(void) {}; + }; + + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_ImageName; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_ImagesNames; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_ImageCount_All; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_DataLayerName; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_RealValue; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_IntegerValue; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_BoolValue; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_BoolValue_YES; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_BoolValue_NO; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_String; + + extern const wchar_t* g_pAutoCalcXML_INParams_Node; + extern const wchar_t* g_pAutoCalcXML_OUTParams_Node; + extern const wchar_t* g_pAutoCalcXML_Params_Param_Node; + extern const wchar_t* g_pAutoCalcXML_Params_ParamName_Node; + extern const wchar_t* g_pAutoCalcXML_Params_ParamType_Node; + extern const wchar_t* g_pAutoCalcXML_Params_ParamValue_Node; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface representing image calculation method class. It should be + /// derived and implemented by developers designing calculation method classes for + /// images processing. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesCalculationMethodI: public mmThread::mmThreadExecutionI + { + public: // definitions + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines calculation method params for automated processing + /// by using calculation patterns. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Definition of calculation method input params in XML. + //////////////////////////////////////////////////////////////////////////////// + wchar_t sInParams[INOUT_PARAMS_SIZE]; + //////////////////////////////////////////////////////////////////////////////// + /// Definition of calculation method output params in XML. + //////////////////////////////////////////////////////////////////////////////// + wchar_t sOutParams[INOUT_PARAMS_SIZE]; + } sCalculationAutomationParams; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines calculation method params defining its functionality and + /// description. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Short name for calculation method. + //////////////////////////////////////////////////////////////////////////////// + wchar_t sShortName[128]; + //////////////////////////////////////////////////////////////////////////////// + /// Unique name for calculation method. + //////////////////////////////////////////////////////////////////////////////// + wchar_t sIDName[128]; + //////////////////////////////////////////////////////////////////////////////// + /// Description of calculation method functionality. + //////////////////////////////////////////////////////////////////////////////// + wchar_t sDescription[INOUT_PARAMS_SIZE]; + //////////////////////////////////////////////////////////////////////////////// + /// It defines if this calculation method can be executed in multithreaded + /// environment. TRUE - it can be multithreaded, FALSE - only one thread for + /// this calculation method is allowed. + //////////////////////////////////////////////////////////////////////////////// + bool bIsMultithreaded; + //////////////////////////////////////////////////////////////////////////////// + /// Automation params definition. + /// See mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams + /// structure description. + //////////////////////////////////////////////////////////////////////////////// + sCalculationAutomationParams sAutoParams; + } sCalculationMethodParams; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmImagesCalculationMethodI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Returns list with available image of points calculation methods. + /// + /// @return vector with mmImages::mmImagesStructureI::sCalculationMethodParams + /// structures defining available calculation methods and their functionality. + //////////////////////////////////////////////////////////////////////////////// + virtual mmImages::mmImagesCalculationMethodI::sCalculationMethodParams GetCalculationMethodInfo(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method initializes parameters for calculation method. It also invokes user interface + /// dialog for input parameters specification or parses automation parameters from XML. + /// + /// @param[in] p_psImagesStructure pointer to mmImages::mmImagesStructureI + /// representing images structure to calculate, + /// @param[in] p_psAutomationParams pointer to mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams + /// structure representing automation params. If NULL than user interface asks + /// user about input parametrs specification, otherwise this structure is + /// parsed and all parameters are set automatically. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetCalculationMethodParameters(mmImages::mmImageStructureI* p_psImagesStructure, + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams = NULL) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Images calculation method container interface. It is responsible for + /// searching all available calculation methods, querying them. It also initializes + /// calculation method objects and return pointers to them. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesCalculationMethodContainerI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmImagesCalculationMethodContainerI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Returns list with available images calculation methods. + /// + /// @return vector with mmImages::mmImagesCalculationMethodI::sCalculationMethodParams + /// structures defining available exporters and their functionality. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetAvailableImagesCalculationMethods(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes selected images calculation method and returns pointer + /// into its interface. In case of error it throws + /// mmError(mmeImagesStructureUnknownImagesCalculationMethod). + /// + /// @param[in] p_sCalculationMethodName name of images calculation method to initialize, + /// @return pointer to initialized mmImages::mmImagesCalculationMethodI object. + //////////////////////////////////////////////////////////////////////////////// + virtual mmImages::mmImagesCalculationMethodI* InitializeImagesCalculationMethod(mmString p_sCalculationMethodName) = 0; + }; +}; + +#endif diff --git a/include/interfaces/mmILog.h b/include/interfaces/mmILog.h new file mode 100644 index 0000000..de68975 --- /dev/null +++ b/include/interfaces/mmILog.h @@ -0,0 +1,67 @@ +//****************************************************************************** +//****************************************************************************** +// +// Log Interface +// +// Description: Specification of logging interfaces. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmILogH +#define mmILogH + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Log organization definitions. +//////////////////////////////////////////////////////////////////////////////// +namespace mmLog +{ + //////////////////////////////////////////////////////////////////////////////// + /// Enumeration with definition of different log priorities. + //////////////////////////////////////////////////////////////////////////////// + typedef enum + { + //////////////////////////////////////////////////////////////////////////////// + /// Debug log message. For any activity of the system. + //////////////////////////////////////////////////////////////////////////////// + debug = 0, + //////////////////////////////////////////////////////////////////////////////// + /// Info log message. Second level of logging activity for raporting + /// of system & user behavior. + //////////////////////////////////////////////////////////////////////////////// + info = 1, + //////////////////////////////////////////////////////////////////////////////// + /// User log message. Used for logging user actions. + //////////////////////////////////////////////////////////////////////////////// + user = 2, + //////////////////////////////////////////////////////////////////////////////// + /// Critical log messages. Used for raporting of critical system events. + //////////////////////////////////////////////////////////////////////////////// + critical = 3 + } eLogMessagePriority; + + //////////////////////////////////////////////////////////////////////////////// + /// Log receiver interface defines functionality for collecting log messages + /// from whole environment. It have to be implemented as thread safe. + //////////////////////////////////////////////////////////////////////////////// + class mmLogReceiverI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmLogReceiverI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method for sending log messages. + /// + /// @param[in] p_ePriority - priority of log message, one of eLogMessagePriority + /// value + /// @param[in] p_psString - pointer to string with message + //////////////////////////////////////////////////////////////////////////////// + virtual void SendLogMessage(eLogMessagePriority p_ePriority,mmString* p_psString) = 0; + }; +}; + +#endif diff --git a/include/interfaces/mmISynchronize.h b/include/interfaces/mmISynchronize.h new file mode 100644 index 0000000..fd6de6f --- /dev/null +++ b/include/interfaces/mmISynchronize.h @@ -0,0 +1,117 @@ +//****************************************************************************** +//****************************************************************************** +// +// Thread and data synchronize Interface +// +// +// Description: Definition of interfaces for synchronization of data or +// threads. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmISynchronizeH +#define mmISynchronizeH + +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Synchronize namespace for all synchronization objects. +//////////////////////////////////////////////////////////////////////////////// +namespace mmSynchronize +{ + //////////////////////////////////////////////////////////////////////////////// + /// Interface for exclusive lock. + //////////////////////////////////////////////////////////////////////////////// + class mmExclusiveLockI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. Clean resources. In case of lock state throws error + /// mmError(mmeExclusiveLockLocked). + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmExclusiveLockI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// TryLock tries to lock. + /// + /// @return true for success, false otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool TryLock(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Wait till successful lock. + //////////////////////////////////////////////////////////////////////////////// + virtual void Lock(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Unlock state. In case of unlocked state throws error + /// mmError(mmeExclusiveLockUnlocked). + //////////////////////////////////////////////////////////////////////////////// + virtual void Unlock(void) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface supporting read/write lock functionality. Gives possibility + /// for multiple read locks and signle write lock. + //////////////////////////////////////////////////////////////////////////////// + class mmReadWriteLockI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. Clean resources. In case of bad end + /// conditions throws exception (if it is locked then throws + /// mmError(mmeReadWriteLockBadEndLockCount), if some object waits for write lock + /// then throws mmError(mmeReadWriteLockWaitForWrite)). + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmReadWriteLockI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Tries to lock for read. + /// + /// @return true for success, false otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool TryLockForRead(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Wait till successful read lock. + //////////////////////////////////////////////////////////////////////////////// + virtual void LockForRead(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Unlock read state. In case of unlocked state throws error + /// mmError(mmeReadWriteLockReadUnlocked). + //////////////////////////////////////////////////////////////////////////////// + virtual void UnlockFromRead(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Tries to lock for write. + /// + /// @return true for success, false otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool TryLockForWrite(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Wait till successful write lock. + //////////////////////////////////////////////////////////////////////////////// + virtual void LockForWrite(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Unlock write state. In case of unlocked state throws error + /// mmError(mmeReadWriteLockWriteUnlocked). + //////////////////////////////////////////////////////////////////////////////// + virtual void UnlockFromWrite(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns state of lock. + /// + /// @param[out] p_pbWaitForWrite TRUE if any object waits for write access, + /// FALSE otherwise, + /// @return integer value representing lock state; - =-1 locked for write, + /// =0 unlocked, =n locked for read by n objects. + //////////////////////////////////////////////////////////////////////////////// + virtual mmInt GetLockState(bool* p_pbWaitForWrite) = 0; + }; +}; + +#endif diff --git a/include/interfaces/mmIThread.h b/include/interfaces/mmIThread.h new file mode 100644 index 0000000..f9be136 --- /dev/null +++ b/include/interfaces/mmIThread.h @@ -0,0 +1,141 @@ +//****************************************************************************** +//****************************************************************************** +// +// Thread Interface +// +// +// Description: This header defines interfaces for threaded work/calculations. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmIThreadH +#define mmIThreadH + +//////////////////////////////////////////////////////////////////////////////// +/// Namespace for multi-threaded work. +//////////////////////////////////////////////////////////////////////////////// +namespace mmThread +{ + //////////////////////////////////////////////////////////////////////////////// + /// This interface defined functionality for executing part of thread + /// which should be implemented in descendant of this class. Methods of + /// this interface are always called by mmThreadI, never directly by user. + //////////////////////////////////////////////////////////////////////////////// + class mmThreadExecutionI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmThreadExecutionI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// This method is called by mmThreadI class. This method should perform + /// all thread work/calculations. + /// + /// @return TRUE if execution is successful, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool Execute(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method is called for stopping current calculation. Class which + /// implements this interface should assure this functionality. + //////////////////////////////////////////////////////////////////////////////// + virtual void StopExecution(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method gives info about execution state. + /// + /// @return TRUE if calculations are in progress, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsExecuting(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns calculation progress as a real value between [0..100] percent. + /// + /// @return real value between [0..100] representing percentage of calculation + /// accomplishment + //////////////////////////////////////////////////////////////////////////////// + virtual mmReal GetProgress(void) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface m5ThreadI defines functionality of thread. + //////////////////////////////////////////////////////////////////////////////// + class mmThreadI + { + public: // definitions + //////////////////////////////////////////////////////////////////////////////// + /// State of thread. + //////////////////////////////////////////////////////////////////////////////// + typedef enum + { + //////////////////////////////////////////////////////////////////////////////// + /// Just created. + //////////////////////////////////////////////////////////////////////////////// + created = 0, + //////////////////////////////////////////////////////////////////////////////// + /// Thread is initialized and it knows his calculation mmThreadExecutionI object. + //////////////////////////////////////////////////////////////////////////////// + initialized = 1, + //////////////////////////////////////////////////////////////////////////////// + /// Thread calculates mmThreadExecutionI tasks. + //////////////////////////////////////////////////////////////////////////////// + running = 2, + //////////////////////////////////////////////////////////////////////////////// + /// Thread is during stopping stage. + //////////////////////////////////////////////////////////////////////////////// + stopping = 3, + //////////////////////////////////////////////////////////////////////////////// + /// Thread is stopped and calculations are not finished. + //////////////////////////////////////////////////////////////////////////////// + stopped = 4, + //////////////////////////////////////////////////////////////////////////////// + /// Thread finished his calculations. + //////////////////////////////////////////////////////////////////////////////// + finished = 5 + } eStatus; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmThreadI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// This method registers class with implementation of mmThreadExecutionI + /// interface which realizes calculation. + /// + /// @param[in] p_psThreadExecutionObject pointer to object with implementation + /// mmThreadExecutionI interface. + //////////////////////////////////////////////////////////////////////////////// + virtual void RegisterThreadExecutionClass(mmThreadExecutionI* p_psThreadExecutionObject) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method starts thread execution. + //////////////////////////////////////////////////////////////////////////////// + virtual void Run(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method stops thread execution. + //////////////////////////////////////////////////////////////////////////////// + virtual void Stop(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method returns state of thread. + /// + /// @return thread state. + //////////////////////////////////////////////////////////////////////////////// + virtual eStatus GetStatus(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns calculation progress as a real value between [0..100] percent. + /// If progress value is less than 0 it means that progress is unavailable. + /// + /// @return real value between [0..100] representing percentage of calculation + /// accomplishment + //////////////////////////////////////////////////////////////////////////////// + virtual mmReal GetProgress(void) = 0; + }; +}; + +#endif diff --git a/include/interfaces/mmIXML.h b/include/interfaces/mmIXML.h new file mode 100644 index 0000000..8868c03 --- /dev/null +++ b/include/interfaces/mmIXML.h @@ -0,0 +1,298 @@ +//****************************************************************************** +//****************************************************************************** +// +// XML Interface +// +// +// Description: This header defines namespace and interfaces for XML data/file manipulation. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmIXMLH +#define mmIXMLH + +#include + +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Namenpace for XML data manipulation. The idea behind is that any XML +/// engine used parses whole XML document into mmXMLDocI and mmXMLNodeI +/// elements structure and all operation are performed in this structure. +/// Further user can save or export resultant data. +//////////////////////////////////////////////////////////////////////////////// +namespace mmXML +{ + //////////////////////////////////////////////////////////////////////////////// + /// XML attribute definition. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Attribute name. + //////////////////////////////////////////////////////////////////////////////// + mmString sName; + //////////////////////////////////////////////////////////////////////////////// + /// Attribute value. + //////////////////////////////////////////////////////////////////////////////// + mmString sValue; + } sXMLAttribute; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for XML node element. + //////////////////////////////////////////////////////////////////////////////// + class mmXMLNodeI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmXMLNodeI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// This method returns name of XML node element. + /// + /// @return name of XML node + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetName(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets new name for XML node element. + /// + /// @param[in] p_sName new name of XML node. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetName(mmString p_sName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns information is this node is leaf of not. + /// + /// @return TRUE if it is leaf, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsLeaf(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns attributes of node. + /// + /// @return vector with node attributes. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetAttributes(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// This method adds attribute to node. + /// + /// @param[in] p_sAttrName name of attribute + /// @param[in] p_sAttrValue value of attribute. + //////////////////////////////////////////////////////////////////////////////// + virtual void AddAttribute(mmString p_sAttrName, + mmString p_sAttrValue) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method removes attribute(s) with given name. In case of lack attribute + /// with given name it throws mmError(mmeXMLNoSuchAttribute). + /// + /// @param[in] p_sAttrName name of attribute. + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveAttribute(mmString p_sAttrName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method removes all attributes. + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveAllAttributes(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method checks if attribute with given name exists. + /// + /// @param[in] p_sAttrName name of attribute. + /// @return TRUE if it exists, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsAttribute(mmString p_sAttrName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Methods returns attribute value. In case of lack attribute + /// with given name it throws mmError(mmeXMLNoSuchAttribute). + /// + /// @param[in] p_sAttrName name of attribute + /// @return value of attribute. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetAttributeValue(mmString p_sAttrName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Methods sets attribute value. In case of lack attribute + /// with given name it adds it. + /// + /// @param[in] p_sAttrName name of attribute + /// @param[in] p_sAttrValue new value of attribute. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetAttributeValue(mmString p_sAttrName, + mmString p_sAttrValue) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns text of node. + /// + /// @return text of node. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString GetText(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method sets text of node. + /// + /// @param[in] p_sText text of node. + //////////////////////////////////////////////////////////////////////////////// + virtual void SetText(mmString p_sText) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns vector with child nodes. + /// + /// @return vector with pointers to elements. + //////////////////////////////////////////////////////////////////////////////// + virtual std::vector GetChilds(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method adds child node. If node has not empty text element it clears it. + /// + /// @param[in] p_sChildName name of new child element + /// @return pointer to created node + //////////////////////////////////////////////////////////////////////////////// + virtual mmXML::mmXMLNodeI* AddChild(mmString p_sChildName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method copies child node and its structure. + /// + /// @param[in] p_psChildNode pointer to node which will be copied + //////////////////////////////////////////////////////////////////////////////// + virtual void AddChildWithStructure(mmXMLNodeI* p_psChildNode) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method finds child node. If child not exist then it returns NULL; + /// + /// @param[in] p_sChildName name of new child element + /// @return pointer to found node + //////////////////////////////////////////////////////////////////////////////// + virtual mmXML::mmXMLNodeI* FindChild(mmString p_sChildName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns pointer to child node. In case of lack node with given index + /// it throws mmError(mmeXMLNoSuchNode). + /// + /// @param[in] p_iChildIndex index of selected child node. + /// @return pointer to selected node + //////////////////////////////////////////////////////////////////////////////// + virtual mmXML::mmXMLNodeI* GetChild(mmInt p_iChildIndex) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method removes child node. In case of lack node with given name it throws + /// mmError(mmeXMLNoSuchNode). + /// + /// @param[in] p_sChildName child node name + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveChild(mmString p_sChildName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method removes child node. In case of lack node with given name it throws + /// mmError(mmeXMLNoSuchNode). + /// + /// @param[in] p_iChildIndex index of selected child node. + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveChild(mmInt p_iChildIndex) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method removes all child nodes. + //////////////////////////////////////////////////////////////////////////////// + virtual void RemoveAllChilds(void) = 0; + //////////////////////////////////////////////////////////////////////////////// + /// Method finds parent node of current node. + /// + /// @return parent node. + //////////////////////////////////////////////////////////////////////////////// + virtual mmXMLNodeI* GetParent( void )=0; + //////////////////////////////////////////////////////////////////////////////// + /// Method finds next sibling of current node. + /// + /// @return next sibling. + //////////////////////////////////////////////////////////////////////////////// + virtual mmXMLNodeI* GetNextSibling( void )=0; + //////////////////////////////////////////////////////////////////////////////// + /// Method finds previous sibling of current node. + /// + /// @return previous sibling. + //////////////////////////////////////////////////////////////////////////////// + virtual mmXMLNodeI* GetPrevSibling( void )=0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for XML document. + //////////////////////////////////////////////////////////////////////////////// + class mmXMLDocI + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmXMLDocI() {}; + + //////////////////////////////////////////////////////////////////////////////// + /// Method parses XML file. In case of error it throws mmError(mmeXMLParseError). + /// + /// @param[in] p_sXMLFileName name of file to parse. + //////////////////////////////////////////////////////////////////////////////// + virtual void ParseXMLFile(mmString p_sXMLFileName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method parses text buffer with XML document. In case of error it throws + /// mmError(mmeXMLParseError). + /// + /// @param[in] p_sXMLBuffer text buffer to parse. + //////////////////////////////////////////////////////////////////////////////// + virtual void ParseXMLBuffer(mmString p_sXMLBuffer) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves mmXMLDocI structure as XML file. In case of error it throws + /// mmError(mmeXMLBadXMLStructure). + /// + /// @param[in] p_sXMLFileName file name to store XML structure. + //////////////////////////////////////////////////////////////////////////////// + virtual void SaveToXMLFile(mmString p_sXMLFileName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method saves mmXMLDocI structure as XML buffer. In case of error it throws + /// mmError(mmeXMLBadXMLStructure). + /// + /// @return string storing XML structure. + //////////////////////////////////////////////////////////////////////////////// + virtual mmString SaveToXMLBuffer(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method validates mmXMLDocI structure. In case of error it throws + /// mmError(mmeXMLBadXMLStructure). + /// + /// @return TRUE if structure is valid, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + virtual bool IsXMLStructureValid(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns root node of mmXMLDocI document. In case of lack node with + /// given name it throws mmError(mmeXMLNoSuchNode). + /// + /// @return pointer to XML node object. + //////////////////////////////////////////////////////////////////////////////// + virtual mmXMLNodeI* GetXMLRootNode(void) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method creates new root node. It deletes whole existing XML structure. + /// + /// @param[in] p_sRootNodeName new root node name. + //////////////////////////////////////////////////////////////////////////////// + virtual void CreateXMLRootNode(mmString p_sRootNodeName) = 0; + + //////////////////////////////////////////////////////////////////////////////// + /// Method creates new root node. It deletes whole existing XML structure. New + /// node is copied from v_psNode with its whole structure. + /// + /// @param[in] p_psNode pointer to new root node source node. + //////////////////////////////////////////////////////////////////////////////// + virtual void CopyXMLRootNodeStructure(mmXMLNodeI* p_psNode) = 0; + }; +}; + +#endif diff --git a/include/log/mmLogSender.h b/include/log/mmLogSender.h new file mode 100644 index 0000000..0625600 --- /dev/null +++ b/include/log/mmLogSender.h @@ -0,0 +1,74 @@ +//****************************************************************************** +//****************************************************************************** +// +// Log Sender class +// +// +// Description: This class implements mmLogReceiverI interface and supports +// all other classes with transparent logging capability. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmLogSenderH +#define mmLogSenderH + +#include + +namespace mmLog +{ + //////////////////////////////////////////////////////////////////////////////// + /// This class support transparent use of logging capability. It should be + /// added as ancestor to any class of the system. + //////////////////////////////////////////////////////////////////////////////// + class mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Name of class which is descendant of mmLogSender class and uses it for logging. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sClassName; + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to mmLogReceiverI object. + //////////////////////////////////////////////////////////////////////////////// + mmLogReceiverI* m_psLog; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Initializes fields. If p_psLog is NULL then logging support is disabled. + /// + /// @param[in] p_sClassName - name of ancestor class. + /// @param[in] p_psLog - pointer to mmLogReceiverI object which receives log messages + //////////////////////////////////////////////////////////////////////////////// + mmLogSender(mmString p_sClassName,mmLogReceiverI* p_psLog = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Method sends a log message with defined priority. If m_psLog is equal NULL + /// then do nothing. + /// + /// @param[in] p_pClassPointer pointer to class sending this message + /// @param[in] p_ePriority type of log message + /// @param[in] p_sString content of message + //////////////////////////////////////////////////////////////////////////////// + void SendLogMessage(void* p_pClassPointer, + eLogMessagePriority p_ePriority, + mmString p_sString); + + //////////////////////////////////////////////////////////////////////////////// + /// Return a pointer to mmLogReceiverI object stored in m_psLog field. + /// + /// @return pointer to log receiver. + //////////////////////////////////////////////////////////////////////////////// + mmLogReceiverI* GetLogReceiver(void); + protected: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Method sends a log message with defined priority. If m_psLog is equal NULL + /// then do nothing. + /// + /// @param[in] p_ePriority type of log message + /// @param[in] p_sString content of message + //////////////////////////////////////////////////////////////////////////////// + void SendLogMessage(mmLog::eLogMessagePriority p_ePriority, + mmString p_sString); + }; +}; + +#endif diff --git a/include/math/mmMath.h b/include/math/mmMath.h new file mode 100644 index 0000000..7519162 --- /dev/null +++ b/include/math/mmMath.h @@ -0,0 +1,1293 @@ +//****************************************************************************** +//****************************************************************************** +// +// Description: This header defines math functionality for the system. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmMathH +#define mmMathH + +#include +#define _USE_MATH_DEFINES 1 +#include + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// This namespace implements math routines used in the system. +//////////////////////////////////////////////////////////////////////////////// +namespace mmMath +{ + extern const mmReal g_rPI; + extern const mmReal g_r2PI; + extern const mmReal g_rPI_div2; + extern const mmReal g_rPIAndMargin; + + extern const mmReal g_rMaxReal; + extern const mmReal g_rMinReal; + + extern const mmFloat g_fMaxFloat; + extern const mmFloat g_fMinFloat; + + extern const mmReal g_rOne; + extern const mmReal g_rSmall; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines two dimensional point with real coords. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X coord. + //////////////////////////////////////////////////////////////////////////////// + mmReal rX; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord. + //////////////////////////////////////////////////////////////////////////////// + mmReal rY; + } sPoint2D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines three dimensional point with real coords. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X coord. + //////////////////////////////////////////////////////////////////////////////// + mmReal rX; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord. + //////////////////////////////////////////////////////////////////////////////// + mmReal rY; + //////////////////////////////////////////////////////////////////////////////// + /// Z coord. + //////////////////////////////////////////////////////////////////////////////// + mmReal rZ; + } sPoint3D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines two dimensional line (y=A*x + B). + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// A coefficient of line. + //////////////////////////////////////////////////////////////////////////////// + mmReal rA; + //////////////////////////////////////////////////////////////////////////////// + /// B coefficient of line. + //////////////////////////////////////////////////////////////////////////////// + mmReal rB; + } sLine2D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines fields required to calculate three dimensional line + /// with real coords by MinRMS method. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Z^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumZ2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXZ; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumYZ; + //////////////////////////////////////////////////////////////////////////////// + /// Points count. + //////////////////////////////////////////////////////////////////////////////// + mmReal rCount; + } sLine3DCalc; + + //////////////////////////////////////////////////////////////////////////////// + /// Values for calculating best fitted polynomial y = ax^3 + bx^2 +cx + d + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Sum of x^6. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX6; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of x^5. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX5; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of x^4. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX4; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of x^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of x^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of x. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of (x^3)*y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX3Y; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of (x^2)*y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2Y; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of xy. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY; + //////////////////////////////////////////////////////////////////////////////// + /// Points count. + //////////////////////////////////////////////////////////////////////////////// + mmReal rCount; + } s3OrderPolynomialXtoYCalc; + + //////////////////////////////////////////////////////////////////////////////// + /// Definition of polynomial y = ax^3 + bx^2 +cx + d + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// A coefficient. + //////////////////////////////////////////////////////////////////////////////// + mmReal rA; + //////////////////////////////////////////////////////////////////////////////// + /// B coefficient. + //////////////////////////////////////////////////////////////////////////////// + mmReal rB; + //////////////////////////////////////////////////////////////////////////////// + /// C coefficient. + //////////////////////////////////////////////////////////////////////////////// + mmReal rC; + //////////////////////////////////////////////////////////////////////////////// + /// D coefficient. + //////////////////////////////////////////////////////////////////////////////// + mmReal rD; + } s3OrderPolynomialXtoY; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines three dimensional line (x-x0)/A = (y-y0)/B = (z-z0)/C. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// A coefficient of line. + //////////////////////////////////////////////////////////////////////////////// + mmReal rA; + //////////////////////////////////////////////////////////////////////////////// + /// B coefficient of line. + //////////////////////////////////////////////////////////////////////////////// + mmReal rB; + //////////////////////////////////////////////////////////////////////////////// + /// C coefficient of line. + //////////////////////////////////////////////////////////////////////////////// + mmReal rC; + //////////////////////////////////////////////////////////////////////////////// + /// Point on line. + //////////////////////////////////////////////////////////////////////////////// + sPoint3D sP; + } sLine3D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines fields required to calculate three dimensional plane + /// with real coords by MinRMS method. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Z^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumZ2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXZ; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumYZ; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumZ; + //////////////////////////////////////////////////////////////////////////////// + /// Points count. + //////////////////////////////////////////////////////////////////////////////// + mmReal rCount; + } sPlane3DCalc; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines plane formula. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// A coefficient of plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rA; + //////////////////////////////////////////////////////////////////////////////// + /// B coefficient of plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rB; + //////////////////////////////////////////////////////////////////////////////// + /// C coefficient of plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rC; + //////////////////////////////////////////////////////////////////////////////// + /// D coefficient of plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rD; + } sPlane3D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines fields required to calculate two dimensional circle + /// with real coords by MinRMS method. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2Y; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY; + //////////////////////////////////////////////////////////////////////////////// + /// Pixels/points count. + //////////////////////////////////////////////////////////////////////////////// + mmReal rCount; + } sCircle2DCalc; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines fields required to calculate three dimensional sphere + /// with real coords by MinRMS method. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2Y; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2Z; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Z^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXZ2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^2*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY2Z; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y*Z^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumYZ2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Z^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumZ3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXZ; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y*Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumYZ; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Z^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumZ2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Z. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumZ; + //////////////////////////////////////////////////////////////////////////////// + /// Pixels/points count. + //////////////////////////////////////////////////////////////////////////////// + mmReal rCount; + } sSphere3DCalc; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines three dimensional sphere with real coords. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X coord of sphere center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rX0; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord of sphere center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rY0; + //////////////////////////////////////////////////////////////////////////////// + /// Z coord of sphere center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rZ0; + //////////////////////////////////////////////////////////////////////////////// + /// Radius of sphere. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRadius; + } sSphere3D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines two dimensional circle with real coords. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X coord of circle center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rX0; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord of circle center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rY0; + //////////////////////////////////////////////////////////////////////////////// + /// Radius of circle. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRadius; + } sCircle2D; + + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X coord of circle center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rX0; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord of circle center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rY0; + //////////////////////////////////////////////////////////////////////////////// + /// Z coord of circle center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rZ0; + //////////////////////////////////////////////////////////////////////////////// + /// Radius of circle. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRadius; + //////////////////////////////////////////////////////////////////////////////// + /// X coord of normal vector to circle plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rA; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord of normal vector to circle plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rB; + //////////////////////////////////////////////////////////////////////////////// + /// Z coord of normal vector to circle plane. + //////////////////////////////////////////////////////////////////////////////// + mmReal rC; + mmReal rPlaneError; + mmReal rCircleError; + } sCircle3D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines fields required to calculate two dimensional ellipse + /// with real coords by MinRMS method. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^4. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX4; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^3*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX3Y; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2*Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2Y2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^4. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY4; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2Y; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^3. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY3; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X*Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumXY; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y^2. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY2; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of X. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumX; + //////////////////////////////////////////////////////////////////////////////// + /// Sum of Y. + //////////////////////////////////////////////////////////////////////////////// + mmReal rSumY; + //////////////////////////////////////////////////////////////////////////////// + /// Pixels/points count. + //////////////////////////////////////////////////////////////////////////////// + mmReal rCount; + } sEllipse2DCalc; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines two dimensional ellipse with real coords. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X coord of ellipse center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rX0; + //////////////////////////////////////////////////////////////////////////////// + /// Y coord of ellipse center. + //////////////////////////////////////////////////////////////////////////////// + mmReal rY0; + //////////////////////////////////////////////////////////////////////////////// + /// Rotation angle of ellipse. + //////////////////////////////////////////////////////////////////////////////// + mmReal rAngle; + //////////////////////////////////////////////////////////////////////////////// + /// Radius in x axis of ellipse. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRadiusA; + //////////////////////////////////////////////////////////////////////////////// + /// Radius in y axis of ellipse. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRadiusB; + //////////////////////////////////////////////////////////////////////////////// + /// Coefficient of canonical form a: a*x^2 + b*2*x*y + c*y^2 + d*x + e*y + f = 0 + //////////////////////////////////////////////////////////////////////////////// + mmReal rA; + //////////////////////////////////////////////////////////////////////////////// + /// Coefficient of canonical form b: a*x^2 + b*2*x*y + c*y^2 + d*x + e*y + f = 0 + //////////////////////////////////////////////////////////////////////////////// + mmReal rB; + //////////////////////////////////////////////////////////////////////////////// + /// Coefficient of canonical form c: a*x^2 + b*2*x*y + c*y^2 + d*x + e*y + f = 0 + //////////////////////////////////////////////////////////////////////////////// + mmReal rC; + //////////////////////////////////////////////////////////////////////////////// + /// Coefficient of canonical form d: a*x^2 + b*2*x*y + c*y^2 + d*x + e*y + f = 0 + //////////////////////////////////////////////////////////////////////////////// + mmReal rD; + //////////////////////////////////////////////////////////////////////////////// + /// Coefficient of canonical form e: a*x^2 + b*2*x*y + c*y^2 + d*x + e*y + f = 0 + //////////////////////////////////////////////////////////////////////////////// + mmReal rE; + //////////////////////////////////////////////////////////////////////////////// + /// Coefficient of canonical form f: a*x^2 + b*2*x*y + c*y^2 + d*x + e*y + f = 0 + //////////////////////////////////////////////////////////////////////////////// + mmReal rF; + } sEllipse2D; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines 3D transformation. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// X translation. + //////////////////////////////////////////////////////////////////////////////// + mmReal rTranslationX; + //////////////////////////////////////////////////////////////////////////////// + /// Y translation. + //////////////////////////////////////////////////////////////////////////////// + mmReal rTranslationY; + //////////////////////////////////////////////////////////////////////////////// + /// Z translation. + //////////////////////////////////////////////////////////////////////////////// + mmReal rTranslationZ; + //////////////////////////////////////////////////////////////////////////////// + /// X rotation. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationX; + //////////////////////////////////////////////////////////////////////////////// + /// Y rotation. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationY; + //////////////////////////////////////////////////////////////////////////////// + /// Z rotation. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationZ; + //////////////////////////////////////////////////////////////////////////////// + /// X rotation sin+. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationXSinP; + //////////////////////////////////////////////////////////////////////////////// + /// X rotation sin-. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationXSinM; + //////////////////////////////////////////////////////////////////////////////// + /// X rotation cos+. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationXCosP; + //////////////////////////////////////////////////////////////////////////////// + /// X rotation cos-. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationXCosM; + //////////////////////////////////////////////////////////////////////////////// + /// Y rotation sin+. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationYSinP; + //////////////////////////////////////////////////////////////////////////////// + /// Y rotation sin-. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationYSinM; + //////////////////////////////////////////////////////////////////////////////// + /// Y rotation cos+. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationYCosP; + //////////////////////////////////////////////////////////////////////////////// + /// Y rotation cos-. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationYCosM; + //////////////////////////////////////////////////////////////////////////////// + /// Z rotation sin+. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationZSinP; + //////////////////////////////////////////////////////////////////////////////// + /// Z rotation sin-. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationZSinM; + //////////////////////////////////////////////////////////////////////////////// + /// Z rotation cos+. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationZCosP; + //////////////////////////////////////////////////////////////////////////////// + /// Z rotation cos-. + //////////////////////////////////////////////////////////////////////////////// + mmReal rRotationZCosM; + } s3DTransformation; + + //////////////////////////////////////////////////////////////////////////////// + /// This structure defines point set. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Vector of pont indexes. + //////////////////////////////////////////////////////////////////////////////// + std::vector vIndexes; + } sFittingPoints; + + //////////////////////////////////////////////////////////////////////////////// + /// Function solves set of linear equations. All fields of table p_sTB have to be + /// non zeros. + /// + /// @param[in] p_psTA input table (size p_iN*p_iN) + /// @param[in,out] p_psTB input/output table (size p_iN) + /// @param[in] p_iN size of tables + //////////////////////////////////////////////////////////////////////////////// + void SolveSetOfLinearEquations(mmReal* p_psTA, + mmReal* p_psTB, + mmInt p_iN); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns smallest power of 2 but bigger than input number. + /// + /// @param[in] p_iInputValue input number + /// @return bigger smallest power of 2 + //////////////////////////////////////////////////////////////////////////////// + mmInt GetSmallestsBiggerPowerOf2(mmInt p_iInputValue); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates vector product in 3D. + /// + /// @param[in] p_sVec1 input vector 1 + /// @param[in] p_sVec2 input vector 2 + /// @return vector + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D CalcVectorProduct3D(mmMath::sPoint3D p_sVec1, + mmMath::sPoint3D p_sVec2); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates circle by minimum RMS criterion. + /// + /// @param[in] p_sCircle2DParams calculated params of circle + /// @return circle definition + //////////////////////////////////////////////////////////////////////////////// + mmMath::sCircle2D CalcCircle2DFormulaByMinRMS(sCircle2DCalc p_sCircle2DParams); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates RMS value from set of distances between p_sPoint3D point + /// and each point in vector pointed by p_pvInPoints. + /// + /// @param[in] p_sPoint3D input point, + /// @param[in] p_pvInPoints pointer to vector of points, + /// @return RMS value calculated. + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPoint3DToPointsRMSError(mmMath::sPoint3D p_sPoint3D, + std::vector* p_pvInPoints); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates RMS value from set of distances between circle center + /// p_sPoint3D point and each point in vector pointed by p_pvInPoints representing + /// points on circumference of a circle. Radius is calculated on base of square + /// root average sum of distances from circle center and rest of points. + /// + /// @param[in] p_sPoint3D circle center, + /// @param[in] p_pvInPoints pointer to vector of points on circumference of a crcle, + /// @return RMS value calculated. + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcCircle3DCenterToPointsRMSError(mmMath::sPoint3D p_sPoint3D, + std::vector* p_pvInPoints); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates formula of circle 3D on base of ponts stored in vector. + /// + /// @param[in] p_pvInPoints pointer to vector of points on circumference of a crcle, + /// @return circle 3D formula calculated. + //////////////////////////////////////////////////////////////////////////////// + mmMath::sCircle3D CalcCircle3DFormulaByMinRMS(std::vector* p_pvInPoints); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates sphere by minimum RMS criterion. + /// + /// @param[in] p_psSphere3DParams calculated params of sphere, + /// @return sphere definition. + //////////////////////////////////////////////////////////////////////////////// + mmMath::sSphere3D CalcSphere3DFormulaByMinRMS(sSphere3DCalc* p_psSphere3DParams); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates sphere by minimum RMS criterion. + /// + /// @param[in] p_pvInPoints pointer to vector of points representing sphere, + /// @return sphere definition. + //////////////////////////////////////////////////////////////////////////////// + mmMath::sSphere3D CalcSphere3DFormulaByMinRMS(std::vector* p_pvInPoints); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates ellipse by minimum RMS criterion. + /// + /// @param[in] p_sEllipse2DParams calculated params of ellipse + /// @return ellipse definition + //////////////////////////////////////////////////////////////////////////////// + mmMath::sEllipse2D CalcEllipse2DFormulaByMinRMS(sEllipse2DCalc p_sEllipse2DParams); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 2D line formula from two points. + /// + /// @param[in] p_sPoint1 point of line + /// @param[in] p_sPoint2 point of line + /// @return line definition + //////////////////////////////////////////////////////////////////////////////// + mmMath::sLine2D CalcLine2D(mmMath::sPoint2D p_sPoint1, + mmMath::sPoint2D p_sPoint2); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D line formula from two points. + /// + /// @param[in] p_sPoint1 point of line + /// @param[in] p_sPoint2 point of line + /// @return line definition + //////////////////////////////////////////////////////////////////////////////// + mmMath::sLine3D CalcLine3D(mmMath::sPoint3D p_sPoint1, + mmMath::sPoint3D p_sPoint2); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D line formula from many points. If A=B=C=0 then + /// line calculation error. + /// + /// @param[in] p_pvPoints pointer to vector with 3D points, + /// @param[out] p_psLineFormula line formula, + /// @return TRUE if success, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + bool CalcBestLine3D(std::vector* p_pvPoints, + mmMath::sLine3D* p_psLineFormula); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D line formula from precalculated sphere calc params + /// and central point (point of line). + /// + /// @param[in] p_sLineCalcValues precalculated values for line formula calculation, + /// @param[in] p_sCentralPoint point of line (in most cases average point), + /// @param[out] p_psLineFormula line formula, + /// @return TRUE if success, FALSE otherwise + //////////////////////////////////////////////////////////////////////////////// + bool CalcBestLine3D(mmMath::sLine3DCalc p_sLineCalcValues, + mmMath::sPoint3D p_sCentralPoint, + mmMath::sLine3D* p_psLineFormula); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D plane formula from three points. + /// + /// @param[in] p_sPoint1 point of plane + /// @param[in] p_sPoint2 point of plane + /// @param[in] p_sPoint3 point of plane + /// @return plane formula + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPlane3D CalcPlane3D(mmMath::sPoint3D p_sPoint1, + mmMath::sPoint3D p_sPoint2, + mmMath::sPoint3D p_sPoint3); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D plane formula from point and vector. + /// + /// @param[in] p_sPoint point of plane + /// @param[in] p_sVector normal vector of plane + /// @return plane formula + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPlane3D CalcPlane3D(mmMath::sPoint3D p_sPoint, + mmMath::sPoint3D p_sVector); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D plane formula from set of points. + /// + /// @param[in] p_vPoints vector with points for plane calculation + /// @param[out] p_prError if not NULL the plane fitting RMS error + /// @return plane formula + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPlane3D CalcBestPlane3D(std::vector p_vPoints, + mmReal* p_prError = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D plane formula from set of points. + /// + /// @param[in] p_prInXYZPoints ponter to array of (x,y,z) points for plane calculation + /// @param[in] p_iXYZPointsCount point count n array p_prInXYZPoints + /// @param[out] p_prError if not NULL the plane fitting RMS error + /// @param[out] p_prMaxError if not NULL the plane fitting maximum error + /// @return plane formula + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPlane3D CalcBestPlane3D(mmReal* p_prInXYZPoints, + mmInt p_iXYZPointsCount, + mmReal* p_prError = NULL, + mmReal* p_prMaxError = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D plane formula from a precalculated structure. + /// + /// @param[in] p_psPlaneCalcParams pointer to precalculated mmMath::sPlane3DCalc + /// structure + /// @return vector with possible plane formulas + //////////////////////////////////////////////////////////////////////////////// + std::vector CalcBestPossiblePlanes3D(mmMath::sPlane3DCalc* p_psPlaneCalcParams); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D point projection on 3D plane. + /// + /// @param[in] p_sPlane3D input plane formula + /// @param[in] p_sPoint3D input point coordinates + /// @return point coordinates + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D CalcPoint3DProjectionOnPlane3D(mmMath::sPlane3D p_sPlane3D, + mmMath::sPoint3D p_sPoint3D); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D point representing intersection of two 3D lines. + /// In case of not crossed lines the closest point to these two lines is + /// returned. + /// + /// @param[in] p_sLine1 input first line formula + /// @param[in] p_sLine2 input second line formula + /// @param[out] p_psPoint coordnates of calculated point + /// @return TRUE if success, FALSE otherwise + //////////////////////////////////////////////////////////////////////////////// + bool CalcLinesIntersection2D(mmMath::sLine2D p_sLine1, + mmMath::sLine2D p_sLine2, + mmMath::sPoint2D* p_psPoint); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates two points from two lines. These points are closest + /// to other line and laying on one line. + /// + /// @param[in] p_sLine1 first line + /// @param[in] p_sLine2 second line + /// @param[out] p_psPointOnLine1 resultant point from line 1 + /// @param[out] p_psPointOnLine2 resultant point from line 2 + /// @return TRUE if success, FALSE otherwise + //////////////////////////////////////////////////////////////////////////////// + bool CalcLineToLineClosestPoints(mmMath::sLine3D p_sLine1, + mmMath::sLine3D p_sLine2, + mmMath::sPoint3D* p_psPointOnLine1, + mmMath::sPoint3D* p_psPointOnLine2); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D distance between line and point. + /// + /// @param[in] p_sPoint point + /// @param[in] p_sLine line + /// @return distance + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPointToLineDistance3D(mmMath::sPoint3D p_sPoint, + mmMath::sLine3D p_sLine); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D distance between plane and point. + /// + /// @param[in] p_sPoint3D point + /// @param[in] p_sPlane3D line + /// @return distance + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPointToPlaneDistance3D(mmMath::sPoint3D p_sPoint3D, + mmMath::sPlane3D p_sPlane3D); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D point projection on 3D line. + /// + /// @param[in] p_sPoint input point coordinates + /// @param[in] p_sLine input line formula + /// @return point coordinates + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D CalcPoint3DProjectionOnLine3D(mmMath::sPoint3D p_sPoint, + mmMath::sLine3D p_sLine); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D distance between point and point. + /// + /// @param[in] p_sPoint1 point 1 + /// @param[in] p_sPoint2 point 2 + /// @return distance + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPointToPointDistance3D(mmMath::sPoint3D p_sPoint1, + mmMath::sPoint3D p_sPoint2); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D distance between point and point. + /// + /// @param[in] p_rPoint1X point 1 x coord + /// @param[in] p_rPoint1Y point 1 y coord + /// @param[in] p_rPoint1Z point 1 z coord + /// @param[in] p_sPoint2X point 2 x coord + /// @param[in] p_sPoint2Y point 2 y coord + /// @param[in] p_sPoint2Z point 2 z coord + /// @return distance + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPointToPointDistance3D(mmReal p_rPoint1X, + mmReal p_rPoint1Y, + mmReal p_rPoint1Z, + mmReal p_rPoint2X, + mmReal p_rPoint2Y, + mmReal p_rPoint2Z); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3D vector length. + /// + /// @param[in] p_sVector vector coordinates + /// @return vector length + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcVector3DLength(mmMath::sPoint3D p_sVector); + + //////////////////////////////////////////////////////////////////////////////// + /// Function normalizes coordinates of 3D vector. + /// + /// @param[in] p_sInVector input vector coordinates + /// @return normalzed vector + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D NormalizeVector3D(mmMath::sPoint3D p_sInVector); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates point after transformation. + /// + /// @param[in] p_psPoint pointer to point + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated point + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D TransformPoint(mmMath::sPoint3D* p_psPoint, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates point after transformation using pre-calculated rotations. + /// + /// @param[in] p_psPoint pointer to point + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated point + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D TransformPointFast(mmMath::sPoint3D* p_psPoint, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates point after inverse transformation. + /// + /// @param[in] p_psPoint pointer to point + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated point + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D UntransformPoint(mmMath::sPoint3D* p_psPoint, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates vector after rotations from transformation. + /// + /// @param[in] p_psVector pointer to vector + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated vector + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D TransformVector(mmMath::sPoint3D* p_psVector, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates vector after inverse rotations from transformation. + /// + /// @param[in] p_psVector pointer to vector + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated vector + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D UntransformVector(mmMath::sPoint3D* p_psVector, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function transforms vector from local to global coords according to + /// defined axes of global coordinate set. + /// + /// @param[in] p_sGlobalXAxis vector with X axis of global coord set + /// @param[in] p_sGlobalYAxis vector with Y axis of global coord set + /// @param[in] p_sGlobalZAxis vector with Z axis of global coord set + /// @param[in] p_sLocalVector vector in local coords to transform + /// @return calculated vector in global coords + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D CalcVectorInGlobalCoords(mmMath::sPoint3D p_sGlobalXAxis, + mmMath::sPoint3D p_sGlobalYAxis, + mmMath::sPoint3D p_sGlobalZAxis, + mmMath::sPoint3D p_sLocalVector); + + //////////////////////////////////////////////////////////////////////////////// + /// Function transforms vector from global to local coords according to + /// defined axes of global coordinate set. + /// + /// @param[in] p_sGlobalXAxis vector with X axis of global coord set + /// @param[in] p_sGlobalYAxis vector with Y axis of global coord set + /// @param[in] p_sGlobalZAxis vector with Z axis of global coord set + /// @param[in] p_sGlobalVector vector in global coords to transform + /// @return calculated vector in local coords + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D CalcVectorInLocalCoords(mmMath::sPoint3D p_sGlobalXAxis, + mmMath::sPoint3D p_sGlobalYAxis, + mmMath::sPoint3D p_sGlobalZAxis, + mmMath::sPoint3D p_sGlobalVector); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates error from p_vStablePoints to p_vToFitPoints + /// using min RMS criterion. + /// + /// @param[in] p_pvStablePoints pointer to set of stable points + /// @param[in] p_pvToFitPoints pointer to set of points to transform + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated error + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPointsToPointsMinRMSError(std::vector* p_pvStablePoints, + std::vector* p_pvToFitPoints, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates best translation (with minimal RMS error) between + /// groups of points with threshold distance. + /// + /// @param[in] p_pvStablePoints pointer to set of stable points + /// @param[in] p_pvToFitPoints pointer to set of points to transform + /// @param[in] p_psTransformation pointer to transformation matrix + /// @param[in] p_rIterationDist transformation distance threshold + /// @return calculated error + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcPointsToPointsBestTranslation(std::vector* p_pvStablePoints, + std::vector* p_pvToFitPoints, + mmMath::s3DTransformation* p_psTransformation, + mmReal p_rIterationDist); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates translation between first points in vectors after + /// transformation. + /// + /// @param[in] p_pvStablePoints pointer to set of stable points + /// @param[in] p_pvToFitPoints pointer to set of points to transform + /// @param[in] p_psTransformation pointer to transformation matrix + /// @return calculated error + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcFirstPointsTranslation(std::vector* p_pvStablePoints, + std::vector* p_pvToFitPoints, + mmMath::s3DTransformation* p_psTransformation); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates simple transformation from p_vStablePoints to p_vToFitPoints + /// using first three poits angles criterion. + /// + /// @param[in] p_vStablePoints set of stable points + /// @param[in] p_vToFitPoints set of points to transform + /// @param[in] p_rIterValue iteration value in [mm] + /// @param[out] p_prFittingError if not NULL then fttng RMS error is returned + /// @return calculated transformation + //////////////////////////////////////////////////////////////////////////////// + mmMath::s3DTransformation CalcInitialPointsToPointsTransformation(std::vector p_vStablePoints, + std::vector p_vToFitPoints, + mmReal p_rIterValue = 1.0, + mmReal* p_prFittingError = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates transformation from p_vStablePoints to p_vToFitPoints + /// using min RMS criterion. + /// + /// @param[in] p_vStablePoints set of stable points + /// @param[in] p_vToFitPoints set of points to transform + /// @param[in] p_rMaxIterValue maximum iteration value in [mm] + /// @param[in] p_rMinIterValue minimum iteration value in [mm] + /// @param[in] p_bLockTranslations if equal to TRUE then translationa are locked + /// @param[in] p_psInitialTransformation initial transformation for iterations + /// @param[out] p_prFittingError if not NULL then fttng RMS error is returned + /// @return calculated transformation + //////////////////////////////////////////////////////////////////////////////// + mmMath::s3DTransformation CalcPointsToPointsTransformation(std::vector p_vStablePoints, + std::vector p_vToFitPoints, + mmReal p_rMaxIterValue = 5.0, + mmReal p_rMinIterValue = 0.000001, + bool p_bLockTranslations = false, + mmMath::s3DTransformation* p_psInitialTransformation = NULL, + mmReal* p_prFittingError = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates transformation from p_vStablePoints to p_vToFitPoints + /// with assumption that points representing a rigid body. It uses min RMS + /// criterion. + /// + /// @param[in] p_vStablePoints set of stable points + /// @param[in] p_vToFitPoints set of points to transform + /// @param[in] p_rMaxIterValue maximum iteration value in [mm] + /// @param[in] p_rMinIterValue minimum iteration value in [mm] + /// @param[in] p_psInitialTransformation initial transformation for iterations + /// @param[out] p_prFittingError if not NULL then fttng RMS error is returned + /// @return calculated transformation + //////////////////////////////////////////////////////////////////////////////// + mmMath::s3DTransformation CalcRigidBodyTransformation(std::vector p_vStablePoints, + std::vector p_vToFitPoints, + mmReal p_rMaxIterValue = 5.0, + mmReal p_rMinIterValue = 0.000001, + mmMath::s3DTransformation* p_psInitialTransformation = NULL, + mmReal* p_prFittingError = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates transformation from p_sStableVector to p_sToFitVector + /// with assumption that only rotations are used. + /// + /// @param[in] p_sStableVector stable vector + /// @param[in] p_sToFitVector to transform vector + /// @param[in] p_bLockXRotation defines if X rotation is used + /// @param[in] p_bLockYRotation defines if Y rotation is used + /// @param[in] p_bLockZRotation defines if Z rotation is used + /// @param[in] p_rMaxIterValueInDeg maximum iteration value in [deg] + /// @param[in] p_rMinIterValueInDeg minimum iteration value in [deg] + /// @param[out] p_prFittingError if not NULL then error is returned + /// @return calculated transformation + //////////////////////////////////////////////////////////////////////////////// + mmMath::s3DTransformation CalcVectorToVectorTransformation(mmMath::sPoint3D p_sStableVector, + mmMath::sPoint3D p_sToFitVector, + bool p_bLockXRotation = false, + bool p_bLockYRotation = false, + bool p_bLockZRotation = false, + mmReal p_rMaxIterValueInDeg = 5.0, + mmReal p_rMinIterValueInDeg = 0.0000001, + mmReal* p_prFittingError = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates plane and line intersection in 3D. + /// + /// @param[in] p_sPlane plane formula + /// @param[in] p_sLine line formula + /// @return calculated point + //////////////////////////////////////////////////////////////////////////////// + mmMath::sPoint3D CalcPlaneAndLineIntersection3D(mmMath::sPlane3D p_sPlane, + mmMath::sLine3D p_sLine); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates 3 order polynomial X to Y. + /// + /// @param[in] p_sInValues plane formula + /// @return definition of polynomial + //////////////////////////////////////////////////////////////////////////////// + mmMath::s3OrderPolynomialXtoY Calc3OrderPolynomialYtoY(mmMath::s3OrderPolynomialXtoYCalc p_sInValues); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates if 2D point is located inside rectangle 2D. + /// + /// @param[in] p_sPoint11 point 1 coordinates + /// @param[in] p_sPoint12 point 2 coordinates + /// @param[in] p_sPoint21 point 3 coordinates + /// @param[in] p_sPoint22 point 4 coordinates + /// @param[in] p_sPoint coordinates of calculated point + /// @return TRUE if it is inside, FALSE otherwise + //////////////////////////////////////////////////////////////////////////////// + bool IsPointInsideRectangle2D(mmMath::sPoint2D p_sPoint11, + mmMath::sPoint2D p_sPoint12, + mmMath::sPoint2D p_sPoint21, + mmMath::sPoint2D p_sPoint22, + mmMath::sPoint2D p_sPoint); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates linear weights of pont inside rectangle. + /// + /// @param[in] p_sPoint11 point 1 coordinates + /// @param[in] p_sPoint12 point 2 coordinates + /// @param[in] p_sPoint21 point 3 coordinates + /// @param[in] p_sPoint22 point 4 coordinates + /// @param[in] p_sPoint coordinates of calculated point + /// @param[out] p_prWeightX pointer to resulting X coords weight + /// @param[out] p_prWeightY pointer to resulting Y coords weight + //////////////////////////////////////////////////////////////////////////////// + void CalcXYWeightsFromRectangle2D(mmMath::sPoint2D p_sPoint11, + mmMath::sPoint2D p_sPoint12, + mmMath::sPoint2D p_sPoint21, + mmMath::sPoint2D p_sPoint22, + mmMath::sPoint2D p_sPoint, + mmReal* p_prWeightX, + mmReal* p_prWeightY); + + //////////////////////////////////////////////////////////////////////////////// + /// Function searches for largest group of points in two sets. Criterion of + /// selection is based on rule that all distances between ponts insode group + /// should be the same for both sets with accuracy less than p_rDistanceThreshold. + /// + /// @param[in] p_pv1stGroupOfPoints pointer to vector with 1st group + /// @param[in] p_pv2ndGroupOfPoints pointer to vector with 2nd group + /// @param[in] p_rDistanceThreshold distance threshold + /// @param[out] p_pvFoundPointIndexes pointer to vector which stores indexes + /// of largest group points + /// @return number of points in largest group + //////////////////////////////////////////////////////////////////////////////// + mmInt FindLargerGroupOfFittingPointsFromOrderedGroups(std::vector* p_pv1stGroupOfPoints, + std::vector* p_pv2ndGroupOfPoints, + mmReal p_rDistanceThreshold, + std::vector* p_pvFoundPointIndexes); + + //////////////////////////////////////////////////////////////////////////////// + /// Function calculates angle between two 3D vectors. + /// + /// @param[in] p_psP3D1 pointer to normalized vector 1 + /// @param[in] p_psP3D2 pointer to normalized vector 2 + /// @return angle in degrees between vectors + //////////////////////////////////////////////////////////////////////////////// + mmReal CalcNormalizedVector3DToNormalizedVector3DAngle(mmMath::sPoint3D* p_psP3D1, + mmMath::sPoint3D* p_psP3D2); +}; + +#endif diff --git a/include/mmCalcMethod.h b/include/mmCalcMethod.h new file mode 100644 index 0000000..0b1d471 --- /dev/null +++ b/include/mmCalcMethod.h @@ -0,0 +1,95 @@ +#pragma once + +#include +#include + +namespace mmImages { + + class mmCalcKernelI; + + class mmCMParameter + { + public: + mmCMParameter(): m_sName(L""), + m_eType(mmXML::g_eXMLUnknownDataType), + m_bIsOutput(false) { } + mmCMParameter(mmString p_sName, + mmXML::mmXMLDataType p_eType, + void* p_psValue, + bool p_bIsOutput = false) + { + m_sName = p_sName; + m_eType = p_eType; + m_bIsOutput = p_bIsOutput; + + switch (m_eType) { + case mmXML::g_eXMLReal: + m_pValue.reset(new mmReal(*reinterpret_cast(p_psValue))); + break; + case mmXML::g_eXMLInt: + m_pValue.reset(new mmInt(*reinterpret_cast(p_psValue))); + break; + case mmXML::g_eXMLString: + case mmXML::g_eXMLImageName: + case mmXML::g_eXMLDataLayerName: + m_pValue.reset(new mmString(*reinterpret_cast(p_psValue))); + break; + case mmXML::g_eXMLBool: + m_pValue.reset(new bool(*reinterpret_cast(p_psValue))); + break; + } + } + ~mmCMParameter() { } + + mmString m_sName; + mmXML::mmXMLDataType m_eType; + mmXML::mmXMLNodePosition m_sPosition; + std::tr1::shared_ptr m_pValue; + bool m_bIsOutput; + }; + + class mmCalcMethod: public mmImagesCalculationMethodI, + public mmCalcMethodExtI, + public mmLog::mmLogSender + { + protected: // methods + virtual bool Calculate() = 0; + virtual void ExecBeforeSingleImageCalc(mmImageI* p_psCurrentImage) = 0; + virtual void ExecAfterSingleImageCalc(mmImageI* p_psCurrentImage) = 0; + virtual void RetrieveParameters() = 0; + + virtual void ForEachImage(mmCalcKernelI* p_psKernel); + virtual void SetParam(mmString p_sName, mmXML::mmXMLDataType p_eType, void* p_psValue, bool p_bIsOutput = false); + virtual const void* GetParam(mmString p_sName); + virtual void GetParam(mmString p_sName, void* p_pValue); + virtual void UpdateParameters(); + virtual std::vector GetImageNames(); + virtual std::vector GetDLNames(mmUInt const p_iImage); + + private: // fields + mmReal m_rProgress; + mmInt m_iThreadsCount; + bool m_bIsExecuting; + bool m_bStopExecution; + bool m_bFinishImage; + std::vector m_vParameters; + std::map m_mNextRows; // next available row for each image in structure which is identified by name + + private: + mmImages::mmImagesCalculationMethodI::sCalculationMethodParams GetCalculationMethodInfo(void); + void SetCalculationMethodParameters(mmImages::mmImageStructureI* p_psImageStructure, mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams = NULL); + + void UserAction(mmString p_sXMLParams); + void UserAction(wchar_t* p_pcXMLParamsBuffer, mmInt p_iXMLParamsBufferSize); + + bool Execute(void); + void StopExecution(void); + bool IsExecuting(void); + mmReal GetProgress(void); + + public: // methods + mmCalcMethod(mmLog::mmLogReceiverI *p_psLogReceiver = NULL, + mmString p_sClassName = L""); + virtual ~mmCalcMethod(); + }; +}; diff --git a/include/mmError.h b/include/mmError.h new file mode 100644 index 0000000..257e909 --- /dev/null +++ b/include/mmError.h @@ -0,0 +1,227 @@ +//****************************************************************************** +//****************************************************************************** +// +// Error codes support +// +// Description: Definition of error suport class. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmErrorH +#define mmErrorH + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Base class for error description. +//////////////////////////////////////////////////////////////////////////////// +class mmError +{ + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Error ID. + //////////////////////////////////////////////////////////////////////////////// + mmInt m_iErrorID; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor requires error ID. + /// + /// @param[in] p_iErrID – error identifier. + //////////////////////////////////////////////////////////////////////////////// + mmError(mmInt p_iErrID); + + //////////////////////////////////////////////////////////////////////////////// + /// Returns error code. + /// + /// @return error code. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetErrorCode(void); + + //////////////////////////////////////////////////////////////////////////////// + /// Returns error string. + //////////////////////////////////////////////////////////////////////////////// + mmString GetErrorString(void); +}; + +//////////////////////////////////////////////////////////////////////////////// +/// Unknown error. +//////////////////////////////////////////////////////////////////////////////// +#define mmeUnknownError 20000 +//////////////////////////////////////////////////////////////////////////////// +/// Allocation error. +//////////////////////////////////////////////////////////////////////////////// +#define mmeBadAlloc 20001 +//////////////////////////////////////////////////////////////////////////////// +/// Input string for processing is too short. +//////////////////////////////////////////////////////////////////////////////// +#define mmeInputStringIsTooSmall 20002 +//////////////////////////////////////////////////////////////////////////////// +/// Log receiver object is already registered in log redirector. +//////////////////////////////////////////////////////////////////////////////// +#define mmeLogReceiverObjectAlreadyRegistered 20003 +//////////////////////////////////////////////////////////////////////////////// +/// Log receiver object is not registered in log redirector. +//////////////////////////////////////////////////////////////////////////////// +#define mmeLogReceiverObjectIsNotRegistered 20004 +//////////////////////////////////////////////////////////////////////////////// +/// Thread throws this error when creation of thread fails. +//////////////////////////////////////////////////////////////////////////////// +#define mmeThreadCreateThreadError 20008 +//////////////////////////////////////////////////////////////////////////////// +/// Thread can't register execution class because thread state is inapriopriate. +//////////////////////////////////////////////////////////////////////////////// +#define mmeThreadCantRegisterExecutionClass 20009 +//////////////////////////////////////////////////////////////////////////////// +/// Thread resume error. +//////////////////////////////////////////////////////////////////////////////// +#define mmeThreadResumeError 20010 +//////////////////////////////////////////////////////////////////////////////// +/// Bad thread state for run. +//////////////////////////////////////////////////////////////////////////////// +#define mmeThreadBadThreadState 20011 +//////////////////////////////////////////////////////////////////////////////// +/// Unknown thread state occurs. +//////////////////////////////////////////////////////////////////////////////// +#define mmeThreadUnknownThreadState 20012 +//////////////////////////////////////////////////////////////////////////////// +/// Error occurs when ExclusiveLock is deleted and his state is still locked. +//////////////////////////////////////////////////////////////////////////////// +#define mmeExclusiveLockLocked 20100 +//////////////////////////////////////////////////////////////////////////////// +/// Error occurs when ExclusiveLock is Unlocked and his state is unlocked already. +//////////////////////////////////////////////////////////////////////////////// +#define mmeExclusiveLockUnlocked 20101 +//////////////////////////////////////////////////////////////////////////////// +/// Error occurs when ReadWriteLock is deleted and his state is still locked. +//////////////////////////////////////////////////////////////////////////////// +#define mmeReadWriteLockBadEndLockCount 20102 +//////////////////////////////////////////////////////////////////////////////// +/// Error occurs when ReadWriteLock is deleted and some object waits for write +/// access. +//////////////////////////////////////////////////////////////////////////////// +#define mmeReadWriteLockWaitForWrite 20103 +//////////////////////////////////////////////////////////////////////////////// +/// Error occurs when ReadWriteLock is unlocked from read and read state is +/// unlocked already. +//////////////////////////////////////////////////////////////////////////////// +#define mmeReadWriteLockReadUnlocked 20104 +//////////////////////////////////////////////////////////////////////////////// +/// Error occurs when ReadWriteLock is unlocked from write and write state is +/// unlocked already. +//////////////////////////////////////////////////////////////////////////////// +#define mmeReadWriteLockWriteUnlocked 20105 + +//////////////////////////////////////////////////////////////////////////////// +/// Unknown error of file access/creation/delete occurs. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOUnknownError 20200 +//////////////////////////////////////////////////////////////////////////////// +/// During file/directory creation/access of unexisting path/file occurs. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIONoSuchFileOrDirectory 20201 +//////////////////////////////////////////////////////////////////////////////// +/// During file/directory access/creation/delete permission error occurs. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOPermissionToFileDenied 20202 +//////////////////////////////////////////////////////////////////////////////// +/// During temporary directory search error occurs. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIONoTemporaryDirectory 20203 +//////////////////////////////////////////////////////////////////////////////// +/// During file opening error occurs. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOCantOpenFile 20204 +//////////////////////////////////////////////////////////////////////////////// +/// During file operation, file is not opened, yet. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOFileIsNotOpened 20205 +//////////////////////////////////////////////////////////////////////////////// +/// Error during file reading. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOCantReadFromFile 20206 +//////////////////////////////////////////////////////////////////////////////// +/// Error during file writing. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOCantWriteToFile 20207 +//////////////////////////////////////////////////////////////////////////////// +/// Error during file position setting. +//////////////////////////////////////////////////////////////////////////////// +#define mmeFileIOBadFilePosition 20208 + +//////////////////////////////////////////////////////////////////////////////// +/// Error during operation on attribute. No such attribute. +//////////////////////////////////////////////////////////////////////////////// +#define mmeXMLNoSuchAttribute 20300 +//////////////////////////////////////////////////////////////////////////////// +/// Error during operation on node. No such node. +//////////////////////////////////////////////////////////////////////////////// +#define mmeXMLNoSuchNode 20301 +//////////////////////////////////////////////////////////////////////////////// +/// Error during parsing XML representation. +//////////////////////////////////////////////////////////////////////////////// +#define mmeXMLParseError 20302 +//////////////////////////////////////////////////////////////////////////////// +/// Error during using XML structure. Invalid structure. +//////////////////////////////////////////////////////////////////////////////// +#define mmeXMLBadXMLStructure 20303 + +//////////////////////////////////////////////////////////////////////////////// +/// Error during reading pixel format - unknown format. +//////////////////////////////////////////////////////////////////////////////// +#define mmeImageProcessingUnknownPixelType 20500 +//////////////////////////////////////////////////////////////////////////////// +/// Error during loading bitmap file, bad format. +//////////////////////////////////////////////////////////////////////////////// +#define mmeImageProcessingBadBitmapPixelFormat 20501 + + +//////////////////////////////////////////////////////////////////////////////// +/// Unknown Images calculation method +//////////////////////////////////////////////////////////////////////////////// +#define mmeImagesStructureUnknownImagesCalculationMethod 30001 +//////////////////////////////////////////////////////////////////////////////// +/// Cannot add new data layer into empty structure +//////////////////////////////////////////////////////////////////////////////// +#define mmeImageStructureCantAddNewDataLayerIntoEmptyStructure 30002 +//////////////////////////////////////////////////////////////////////////////// +/// User wanted to get data from non-existing channel +//////////////////////////////////////////////////////////////////////////////// +#define mmeImageStructureNoChannel 30003 +//////////////////////////////////////////////////////////////////////////////// +/// There is no such datalayer +//////////////////////////////////////////////////////////////////////////////// +#define mmeImageStructureNoSuchAdditionalDataLayer 30004 +#define mmeHardwareBadRangeForParamsValue 20401 + +#define mmeHardwareCantCapture 20402 +//////////////////////////////////////////////////////////////////////////////// +/// Error during image reading from detector, index out of range. +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareImageOutOfRange 20403 +//////////////////////////////////////////////////////////////////////////////// +/// Error during initialisation of hardware component. +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareInitialisationError 20404 +//////////////////////////////////////////////////////////////////////////////// +/// Error during accessing hardware when it is not initialized. +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareNotInitialised 20405 +//////////////////////////////////////////////////////////////////////////////// +/// Error in detector name for initialization. +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareUnknownDetector 20406 +//////////////////////////////////////////////////////////////////////////////// +/// Error in projector name for initialization. +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareUnknownProjector 20407 +//////////////////////////////////////////////////////////////////////////////// +/// Error in manipulator name for initialization. +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareUnknownManipulator 20408 +//////////////////////////////////////////////////////////////////////////////// +/// Error during setting hardware parameters +//////////////////////////////////////////////////////////////////////////////// +#define mmeHardwareCantSetParameter 20409 + + +#endif diff --git a/include/mmGlobalDefs.h b/include/mmGlobalDefs.h new file mode 100644 index 0000000..3386b98 --- /dev/null +++ b/include/mmGlobalDefs.h @@ -0,0 +1,42 @@ +//****************************************************************************** +//****************************************************************************** +// +// +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmGlobalDefsH +#define mmGlobalDefsH + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of type representing real value +//////////////////////////////////////////////////////////////////////////////// +typedef double mmReal; + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of type representing real(float) value +//////////////////////////////////////////////////////////////////////////////// +typedef float mmFloat; + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of type representing integer value +//////////////////////////////////////////////////////////////////////////////// +typedef int mmInt; + +typedef unsigned mmUInt; + +typedef struct { + mmUInt iLeft; + mmUInt iTop; + mmUInt iWidth; + mmUInt iHeight; +} mmRect; + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of type representing std::string value +//////////////////////////////////////////////////////////////////////////////// +typedef std::wstring mmString; + +#endif diff --git a/include/mmInterfaceInitializers.h b/include/mmInterfaceInitializers.h new file mode 100644 index 0000000..9a04ed9 --- /dev/null +++ b/include/mmInterfaceInitializers.h @@ -0,0 +1,148 @@ +//****************************************************************************** +//****************************************************************************** +// +// Interface initalizers +// +// +// Description: Set of functions for unified interface initialization. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmInterfaceInitializersH +#define mmInterfaceInitializersH + +#include +#include +#include +#include + +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Namespace for interface initializers. +//////////////////////////////////////////////////////////////////////////////// +namespace mmInterfaceInitializers +{ + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmSynchronize::mmExclusiveLockI. In case of bad alloc + /// error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmSynchronize::mmExclusiveLockI* CreateExclusiveLock(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmSynchronize::mmReadWriteLockI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmSynchronize::mmReadWriteLockI* CreateReadWriteLock(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmFileIO::mmFileUtilsI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmFileIO::mmFileUtilsI* CreateFileUtils(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmFileIO::mmTextFileReadI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmFileIO::mmTextFileReadI* CreateTextFileForRead(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmFileIO::mmBinaryFileReadI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmFileIO::mmBinaryFileReadI* CreateBinaryFileForRead(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmFileIO::mmTextFileWriteI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmFileIO::mmTextFileWriteI* CreateTextFileForWrite(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmFileIO::mmBinaryFileWriteI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmFileIO::mmBinaryFileWriteI* CreateBinaryFileForWrite(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmLog::mmLogReceiverI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_sLogFileName name of log file + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmLog::mmLogReceiverI* CreateLogFile(mmString p_sLogFileName); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmXML::mmXMLDocI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmXML::mmXMLDocI* CreateXMLDocument(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmXML::mmXMLNodeI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmXML::mmXMLNodeI* CreateXMLNode(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmThread::mmThreadI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmThread::mmThreadI* CreateDefaultThread(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmImages::mmImagesStructureI. In case of + /// bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmImages::mmImageStructureI* CreateDefaultImageStructure(mmImages::mmImageI::mmCallbackI * p_psCallback, + mmLog::mmLogReceiverI* p_psLogReceiver); + + //////////////////////////////////////////////////////////////////////////////// + /// Initializes interface mmImages::mmImagesCalculationMethodContainerI. + /// In case of bad alloc error throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psUIMainWindow pointer to UI main window object + /// @param[in] p_psLogReceiver pointer to log object + /// @return pointer to initialized object + //////////////////////////////////////////////////////////////////////////////// + mmImages::mmImagesCalculationMethodContainerI* CreateDefaultImagesCalculationMethodContainer(mmLog::mmLogReceiverI* p_psLogReceiver = NULL); + +}; + +#endif diff --git a/include/mmOperatingSystemCalls.h b/include/mmOperatingSystemCalls.h new file mode 100644 index 0000000..49bfb11 --- /dev/null +++ b/include/mmOperatingSystemCalls.h @@ -0,0 +1,121 @@ +//****************************************************************************** +//****************************************************************************** +// +// Operating system calls +// +// Description: All operating system calls for the system. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmOperatingSystemCallsH +#define mmOperatingSystemCallsH +#include +#include + +#include + +#include +#include +#include + +#define OS_NAME "WindowsNT" + +//////////////////////////////////////////////////////////////////////////////// +/// Namespace with all operating system calls. Hides system dependency for +/// the system. +//////////////////////////////////////////////////////////////////////////////// +namespace mmOperatingSystem +{ + //////////////////////////////////////////////////////////////////////////////// + /// Returns current thread identifier. + /// + /// @return thread ID + //////////////////////////////////////////////////////////////////////////////// + mmInt GetCurrentThreadID(void); + + //////////////////////////////////////////////////////////////////////////////// + /// Function creates directory in specified location. In case of error it throws + /// mmeFileIONoSuchFileOrDirectory, mmeFileIOPermissionToFileDenied + /// or mmeUnknownError. + /// + /// @param[in] p_sDirName name with full path for new directory + //////////////////////////////////////////////////////////////////////////////// + void CreateDir(mmString p_sDirName); + //////////////////////////////////////////////////////////////////////////////// + /// Function deletes directory from specified location. In case of error it throws + /// mmeFileIONoSuchFileOrDirectory, mmeFileIOPermissionToFileDenied + /// or mmeUnknownError. + /// + /// @param[in] p_sDirName name with full path for deleted directory + //////////////////////////////////////////////////////////////////////////////// + void RemoveDir(mmString p_sDirName); + //////////////////////////////////////////////////////////////////////////////// + /// Function checks if specified directory exist. + /// + /// @param[in] p_sDirName path to checked directory + /// @return TRUE if directory exists, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + bool IsExistingDir(mmString p_sDirName); + //////////////////////////////////////////////////////////////////////////////// + /// Function returns directory to application executable file. + /// + /// @return full path to application executable. + //////////////////////////////////////////////////////////////////////////////// + mmString GetApplicationDirectory(void); + //////////////////////////////////////////////////////////////////////////////// + /// Function returns application executable file name. + /// + /// @return name only of application executable. + //////////////////////////////////////////////////////////////////////////////// + mmString GetApplicationName(void); + //////////////////////////////////////////////////////////////////////////////// + /// Function returns full path to current working directory. In case of error + /// it throws mmeUnknownError. + /// + /// @return path to current directory + //////////////////////////////////////////////////////////////////////////////// + mmString GetCurrentWorkingDir(void); + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns vector with elemens located in specified directory. + /// In case of error it throws mmeFileIONoSuchFileOrDirectory or mmeUnknownError. + /// + /// @param[in] p_sDirName path to directory + /// @param[in] p_sDirWildcards string with wildcards definition + /// @return vector with directory content. + //////////////////////////////////////////////////////////////////////////////// + std::vector GetDirectoryElements(mmString p_sDirName, + mmString p_sDirWildcards); + + //////////////////////////////////////////////////////////////////////////////// + /// Function checks if requested file exist. + /// + /// @param[in] p_sFileName name with full path to file + /// @return TRUE if file exists, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + bool IsExistingFile(mmString p_sFileName); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns time in seconds from application start. Returned time + /// can be used for measuring calculation times. + /// + /// @return time in seconds from application start + //////////////////////////////////////////////////////////////////////////////// + mmReal GetApplicationTime(void); + + //////////////////////////////////////////////////////////////////////////////// + /// This function stops thread execution for p_iMiliSeconds. + /// + /// @param[in] p_iMiliSeconds miliseconds + //////////////////////////////////////////////////////////////////////////////// + void StopThread(mmInt p_iMiliSeconds); + + //////////////////////////////////////////////////////////////////////////////// + /// Method returns string with unique ID. + /// + /// @return ID string + //////////////////////////////////////////////////////////////////////////////// + mmString GetUniqueIDString(void); +}; + +#endif diff --git a/include/mmPixel.h b/include/mmPixel.h new file mode 100644 index 0000000..8923576 --- /dev/null +++ b/include/mmPixel.h @@ -0,0 +1,76 @@ +#ifndef mmPixelH +#define mmPixelH + +#include + +struct mmPixel8; +struct mmPixel24; +struct mmPixel32; + +struct mmPixel8 { + mmPixel8(void); + mmPixel8(mmReal const p_rI); + + static mmUInt const iComponents; + + mmReal rI; +}; + +struct mmPixel24 { + mmPixel24(void); + mmPixel24(mmReal const p_rR, mmReal const p_rG, mmReal const p_rB); + mmPixel24(mmPixel8 const & p_smmPixel8); + + static mmUInt const iComponents; + + mmReal rR, rG, rB; +}; + +struct mmPixel32 { + mmPixel32(void); + mmPixel32(mmReal const p_rR, mmReal const p_rG, mmReal const p_rB, mmReal const p_rA); + mmPixel32(mmPixel8 const & p_smmPixel8); + mmPixel32(mmPixel24 const & p_smmPixel24); + + static mmUInt const iComponents; + + mmReal rR, rG, rB, rA; +}; + +extern mmPixel8 operator + (mmPixel8 p_sP1, mmPixel8 const & p_sP2); +extern mmPixel8 operator - (mmPixel8 p_sP1, mmPixel8 const & p_sP2); +extern mmPixel8 operator += (mmPixel8 & p_sP1, mmPixel8 const & p_sP2); +extern mmPixel8 operator -= (mmPixel8 & p_sP1, mmPixel8 const & p_sP2); + +extern mmPixel8 operator * (mmPixel8 p_sP, mmReal const p_sS); +extern mmPixel8 operator * (mmReal const p_sS, mmPixel8 p_sP); +extern mmPixel8 operator / (mmPixel8 p_sP, mmReal const p_sS); +extern mmPixel8 operator *= (mmPixel8 & p_sP, mmReal const p_sS); +extern mmPixel8 operator *= (mmReal const p_sS, mmPixel8 & p_sP); +extern mmPixel8 operator /= (mmPixel8 & p_sP, mmReal const p_sS); + +extern mmPixel24 operator + (mmPixel24 p_sP1, mmPixel24 const & p_sP2); +extern mmPixel24 operator - (mmPixel24 p_sP1, mmPixel24 const & p_sP2); +extern mmPixel24 operator += (mmPixel24 & p_sP1, mmPixel24 const & p_sP2); +extern mmPixel24 operator -= (mmPixel24 & p_sP1, mmPixel24 const & p_sP2); + +extern mmPixel24 operator * (mmPixel24 p_sP, mmReal const p_sS); +extern mmPixel24 operator * (mmReal const p_sS, mmPixel24 p_sP); +extern mmPixel24 operator / (mmPixel24 p_sP, mmReal const p_sS); +extern mmPixel24 operator *= (mmPixel24 & p_sP, mmReal const p_sS); +extern mmPixel24 operator *= (mmReal const p_sS, mmPixel24 & p_sP); +extern mmPixel24 operator /= (mmPixel24 & p_sP, mmReal const p_sS); + +extern mmPixel32 operator + (mmPixel32 p_sP1, mmPixel32 const & p_sP2); +extern mmPixel32 operator - (mmPixel32 p_sP1, mmPixel32 const & p_sP2); +extern mmPixel32 operator += (mmPixel32 & p_sP1, mmPixel32 const & p_sP2); +extern mmPixel32 operator -= (mmPixel32 & p_sP1, mmPixel32 const & p_sP2); + +extern mmPixel32 operator * (mmPixel32 p_sP, mmReal const p_sS); +extern mmPixel32 operator * (mmReal const p_sS, mmPixel32 p_sP); +extern mmPixel32 operator / (mmPixel32 p_sP, mmReal const p_sS); +extern mmPixel32 operator *= (mmPixel32 & p_sP, mmReal const p_sS); +extern mmPixel32 operator *= (mmReal const p_sS, mmPixel32 & p_sP); +extern mmPixel32 operator /= (mmPixel32 & p_sP, mmReal const p_sS); + +#endif \ No newline at end of file diff --git a/include/mmStringUtilities.h b/include/mmStringUtilities.h new file mode 100644 index 0000000..d8c8ff4 --- /dev/null +++ b/include/mmStringUtilities.h @@ -0,0 +1,177 @@ +//****************************************************************************** +//****************************************************************************** +// +// String utilities +// Description: This namespace extends functionality of std::string. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmStringUtilitiesH +#define mmStringUtilitiesH + +#include +#include + +#include +#include + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Namespace with extension of std::string functionality. +//////////////////////////////////////////////////////////////////////////////// +namespace mmStringUtilities +{ + //////////////////////////////////////////////////////////////////////////////// + /// Converts boolean value to string. + /// + /// @param[in] p_bInput boolean value + /// @return string representation of p_bInput + //////////////////////////////////////////////////////////////////////////////// + mmString BoolToString(bool p_bInput); + //////////////////////////////////////////////////////////////////////////////// + /// Converts integer value into string. + /// + /// @param[in] p_iInput integer value + /// @param[in] p_iLength output string lenght (fill by 0) + /// @return string representation of p_iInput + //////////////////////////////////////////////////////////////////////////////// + mmString MMIntToString(mmInt p_iInput, + mmInt p_iLength = 0); + //////////////////////////////////////////////////////////////////////////////// + /// Converts real value to string + /// + /// @param[in] p_rInput real value + /// @param[in] p_iPrecision number of digits after dot + /// @return output string. + //////////////////////////////////////////////////////////////////////////////// + mmString MMRealToString(mmReal p_rInput,mmInt p_iPrecision = -1); + //////////////////////////////////////////////////////////////////////////////// + /// Converts pointer to string. + /// + /// @param[in] p_pInput input pointer + /// @return output string. + //////////////////////////////////////////////////////////////////////////////// + mmString PointerToString(void* p_pInput); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts image pixel format to human readable string + //////////////////////////////////////////////////////////////////////////////// + mmString PixelFormatToString(mmImageProcessing::ePixelType p_ePixelType); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts string to image pixel format + //////////////////////////////////////////////////////////////////////////////// + mmImageProcessing::ePixelType StringToPixelFormat(mmString p_sStr); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts string to integer value + /// + /// @param[in] p_sStr input string + /// @return output integer + //////////////////////////////////////////////////////////////////////////////// + mmInt StringToMMInt(mmString p_sStr); + //////////////////////////////////////////////////////////////////////////////// + /// Converts string to mmReal value + /// + /// @param[in] p_sStr input string + /// @return output mmReal + //////////////////////////////////////////////////////////////////////////////// + mmReal StringToMMReal(mmString p_sStr); + //////////////////////////////////////////////////////////////////////////////// + /// Converts string to boolean value. + /// + /// @param[in] p_sStr input string + /// @return output boolean + //////////////////////////////////////////////////////////////////////////////// + bool StringToBool(mmString p_sStr); + + //////////////////////////////////////////////////////////////////////////////// + /// This function returns formatted date/time string. + /// + /// @return formatted date/time string + //////////////////////////////////////////////////////////////////////////////// + mmString GetCurrentDateTimeString(void); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts integer value representing seconds into string HH:MM:SS. + /// + /// @param[in] p_iInput integer value + /// @return string representation of p_iInput + //////////////////////////////////////////////////////////////////////////////// + mmString MMIntToHHMMSSString(mmInt p_iInput); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts std::string to mmString format using STL mechanism. + /// + /// @param[in] p_sInputString single byte string, + /// @return converted mmString. + //////////////////////////////////////////////////////////////////////////////// + mmString MMCharStringToMMString(const std::string p_sInputString); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts mmString to std::strng format using STL mechanism. + /// + /// @param[in] p_sInputString mmString string, + /// @return converted std::string. + //////////////////////////////////////////////////////////////////////////////// + std::string MMStringToCharString(const mmString p_sInputString); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts mmString to vector with integer values. + /// + /// @param[in] p_sInputString mmString string, + /// @return vector of ints. + //////////////////////////////////////////////////////////////////////////////// + std::vector MMStringToVectorOfInt(const mmString p_sInputString); + + //////////////////////////////////////////////////////////////////////////////// + /// Converts mmString to vector with sub-string values. Delimiter is space char. + /// + /// @param[in] p_sInputString mmString string, + /// @return vector of mmStrings. + //////////////////////////////////////////////////////////////////////////////// + std::vector MMStringToVectorOfMMString(const mmString p_sInputString); + + //////////////////////////////////////////////////////////////////////////////// + /// Uppers input mmString. + /// + /// @param[in] p_sInputString mmString string, + /// @return uppered string. + //////////////////////////////////////////////////////////////////////////////// + mmString MMStringToUpper(const mmString p_sInputString); + //////////////////////////////////////////////////////////////////////////////// + /// Tokenizes input string. + /// + /// @param[in] p_sInputString mmString string, + /// @param[out] v_vcTokens vector of tokens, + /// @param[inopt] _p_sFromString pointer to function able to convert a string to + /// the specified output type, not required if the output type is a basic type + /// that can be converted using STL streams. + //////////////////////////////////////////////////////////////////////////////// + template< class T > + void Tokenize( mmString p_tString, wchar_t p_wcDelimiter, std::vector &p_vcTokens, T (*_p_sFromString)( mmString& ) = NULL ) { + std::wstringstream v_sStream( p_tString ); + std::wstringstream v_sTokenStream; + wchar_t v_wcTmp; + T v_sToken; + std::wstring v_wsToken; + p_vcTokens.clear(); + while( ! v_sStream.eof() ) { + v_sStream >> v_wcTmp; + if( v_wcTmp == p_wcDelimiter || v_sStream.eof() ) { + if( _p_sFromString != NULL ) { + v_sTokenStream >> v_wsToken; + v_sToken = (*_p_sFromString)( v_wsToken ); + } else + v_sTokenStream >> v_sToken; + if( ! ! v_sTokenStream ) + p_vcTokens.push_back( v_sToken ); + v_sTokenStream.clear(); + } else + v_sTokenStream << v_wcTmp; + } + } +}; + +#endif diff --git a/include/mmXMLIOUtilities.h b/include/mmXMLIOUtilities.h new file mode 100644 index 0000000..c6c6ce5 --- /dev/null +++ b/include/mmXMLIOUtilities.h @@ -0,0 +1,63 @@ +//--------------------------------------------------------------------------- + +#ifndef mmXMLIOUtilitiesH +#define mmXMLIOUtilitiesH +//--------------------------------------------------------------------------- +#include +#include +#include +#include +#include + +using namespace mmStringUtilities; + +namespace mmXML { + typedef std::size_t mmUInt; + typedef struct { mmInt iGroupIndex; mmInt iLeafIndex; } mmXMLNodePosition; + typedef struct { mmXMLNodeI * _v_xNode; mmXMLNodePosition sPosition; } mmXMLPositionedNode; + enum mmXMLDataType { g_eXMLReal = 0x00, g_eXMLInt=0x01, g_eXMLString=0x02, g_eXMLBool=0x03, g_eXMLImageName=0x04, g_eXMLDataLayerName=0x05, g_eXMLUnknownDataType=0x07 }; + enum mmXMLAutoType { g_eXMLAutoInput=0x00, g_eXMLAutoOutput=0x01 }; + + class mmXMLNodePath { + public: + typedef struct { mmString tName; mmInt iIndex; } mmXMLNodeID; + mmXMLNodePath( void ); + mmXMLNodePath( mmString const & p_usPath ); + mmXMLNodePath& operator += ( mmString const & p_tPath ); + mmXMLNodePath& operator += ( mmXMLNodeID const & p_sNode ); + void operator = ( mmString const & p_tPath ); + bool operator == ( mmXMLNodePath const & p_sNodePath ) const; + operator mmXMLNodeID() const; + void Reset( void ) const; + bool End( void ) const; + mmString ToString( void ) const; + void Reverse( void ); + void Norm( void ); + private: + struct MakeZero { void operator () ( mmXMLNodeID & p_sNode ) const { p_sNode.iIndex = 0; } }; + std::list m_lsPath; + mutable std::list::const_iterator m_lsiCurrent; + void AddString( mmString const & p_tPath ); + }; + + bool IsValidNodePosition( mmXMLNodePosition p_xNodePosition ); + mmXMLPositionedNode CreateAutomation( mmXMLDocI * _p_xDoc, mmXMLAutoType p_eXMLAutoType ); + mmXMLPositionedNode CreateAutomationInput( mmXMLDocI * _p_xDoc ); + mmXMLPositionedNode CreateAutomationOutput( mmXMLDocI * _p_xDoc ); + mmXMLNodePosition AddParam( mmXMLPositionedNode * _p_xPositionedRootNode, mmString p_tName, mmXMLDataType p_eType, void * _p_DefaultValue = NULL ); + mmXMLNodePosition AddParam( mmXMLPositionedNode * _p_xPositionedRootNode, mmString p_tName, mmXMLDataType p_eType, mmString p_tDefaultValue ); + void CopyInputParams( mmXMLDocI * _p_xDoc, mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams ); + void CopyOutputParams( mmXMLDocI * _p_xDoc, mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams ); + void UpdateOutputParam( mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams, mmXMLNodePosition p_xNodePosition, void * _p_OutputValue ); + void UpdateOutputParam( mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams, mmXMLNodePosition p_xNodePosition, mmString p_tOutputValue ); + bool GetValueByName( mmXML::mmXMLDocI * _p_xDoc, mmString p_tParamName, void * _p_OutputPointer ); + bool GetValue( mmXMLDocI * _p_xDoc, mmXMLNodePosition p_xNodePosition, void * _p_OutputPointer ); + bool SetValueByName( mmXML::mmXMLDocI * _p_xDoc, mmString p_tParamName, void * _p_InputPointer ); + bool SetValue( mmXMLDocI * _p_xDoc, mmXMLNodePosition p_xNodePosition, void * _p_InputPointer ); + mmString GetTypeTransition( mmXMLDataType p_eDataType ); + mmXMLDataType GetTypeTransition( mmString p_tType ); + mmString ConvertToString( mmXMLDataType p_eType, void * _p_Data ); + mmXMLNodeI* GetNodeAt( mmXMLNodeI* _p_sRootNode, mmXMLNodePath const & p_sNodePath, bool p_bCreateNode ); +} + +#endif diff --git a/lib/Debug/libcalc2dmath.lib b/lib/Debug/libcalc2dmath.lib new file mode 100644 index 0000000..eb26628 Binary files /dev/null and b/lib/Debug/libcalc2dmath.lib differ diff --git a/lib/Release/libcalc2dmath.lib b/lib/Release/libcalc2dmath.lib new file mode 100644 index 0000000..97407ab Binary files /dev/null and b/lib/Release/libcalc2dmath.lib differ diff --git a/lib/x64/Debug/libcalc2dmath.lib b/lib/x64/Debug/libcalc2dmath.lib new file mode 100644 index 0000000..dae3135 Binary files /dev/null and b/lib/x64/Debug/libcalc2dmath.lib differ diff --git a/lib/x64/Release/libcalc2dmath.lib b/lib/x64/Release/libcalc2dmath.lib new file mode 100644 index 0000000..0d49bdf Binary files /dev/null and b/lib/x64/Release/libcalc2dmath.lib differ diff --git a/proj/calc2d/calc2d.cpp b/proj/calc2d/calc2d.cpp new file mode 100644 index 0000000..a70b5e4 --- /dev/null +++ b/proj/calc2d/calc2d.cpp @@ -0,0 +1,23 @@ +// calc2d.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include +#include +#include +#include + + +using namespace mmImages; + +int _tmain(int argc, _TCHAR* argv[]) +{ + mmImagesCalculationManagement calc_mgr(3, NULL); + mmImagesCalculationMethodContainerForWindows methods_mgr(NULL); + std::auto_ptr image(mmInterfaceInitializers::CreateDefaultImageStructure(NULL, NULL)); + + //methods_mgr.GetAvailableImagesCalculationMethods(); + + return 0; +} + diff --git a/proj/calc2d/calc2d.vcxproj b/proj/calc2d/calc2d.vcxproj new file mode 100644 index 0000000..725a5ab --- /dev/null +++ b/proj/calc2d/calc2d.vcxproj @@ -0,0 +1,169 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {51B17ACA-BAC0-408E-8145-B366393F0734} + Win32Proj + calc2d + calc2d + + + + Application + true + Unicode + + + Application + true + Unicode + + + Application + false + true + Unicode + + + Application + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\$(IntDir) + $(Platform)\$(Configuration)\ + + + true + $(SolutionDir)bin\$(IntDir) + $(Platform)\$(Configuration)\ + + + false + $(SolutionDir)bin\$(IntDir) + $(Platform)\$(Configuration)\ + + + false + $(SolutionDir)bin\$(IntDir) + $(Platform)\$(Configuration)\ + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)\include;$(SolutionDir)\proj\libcalc2d\include + + + Console + true + $(SolutionDir)lib\$(Configuration) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies);libcalc2d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)\include;$(SolutionDir)\proj\libcalc2d\include + + + Console + true + $(SolutionDir)lib\$(Platform)\$(Configuration)\ + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies);libcalc2d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)\include;$(SolutionDir)\proj\libcalc2d\include + + + Console + true + true + true + $(SolutionDir)lib\$(Configuration) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies);libcalc2d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + $(SolutionDir)\include;$(SolutionDir)\proj\libcalc2d\include + + + Console + true + true + true + $(SolutionDir)lib\$(Platform)\$(Configuration)\ + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies);libcalc2d.lib + + + + + + + + + + + + + + \ No newline at end of file diff --git a/proj/calc2d/calc2d.vcxproj.filters b/proj/calc2d/calc2d.vcxproj.filters new file mode 100644 index 0000000..9e22c24 --- /dev/null +++ b/proj/calc2d/calc2d.vcxproj.filters @@ -0,0 +1,33 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/proj/calc2d/stdafx.cpp b/proj/calc2d/stdafx.cpp new file mode 100644 index 0000000..4db124b --- /dev/null +++ b/proj/calc2d/stdafx.cpp @@ -0,0 +1,8 @@ +// stdafx.cpp : source file that includes just the standard includes +// calc2d.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/proj/calc2d/stdafx.h b/proj/calc2d/stdafx.h new file mode 100644 index 0000000..47a0d02 --- /dev/null +++ b/proj/calc2d/stdafx.h @@ -0,0 +1,15 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + +#include "targetver.h" + +#include +#include + + + +// TODO: reference additional headers your program requires here diff --git a/proj/calc2d/targetver.h b/proj/calc2d/targetver.h new file mode 100644 index 0000000..90e767b --- /dev/null +++ b/proj/calc2d/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// Including SDKDDKVer.h defines the highest available Windows platform. + +// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and +// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. + +#include diff --git a/proj/libcalc2d/Calculation2D.vcxproj b/proj/libcalc2d/Calculation2D.vcxproj new file mode 100644 index 0000000..fbab503 --- /dev/null +++ b/proj/libcalc2d/Calculation2D.vcxproj @@ -0,0 +1,228 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + libcalc2d + {81764A51-4B0F-4310-ACD1-059BFC9BEDDE} + OGX2Dlib + Win32Proj + + + + StaticLibrary + Unicode + + + StaticLibrary + Unicode + + + StaticLibrary + Unicode + + + StaticLibrary + Unicode + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>10.0.30319.1 + $(SolutionDir)lib\$(IntDir) + $(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(IntDir) + $(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(IntDir) + $(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(IntDir) + $(Platform)\$(Configuration)\ + AllRules.ruleset + + + AllRules.ruleset + + + AllRules.ruleset + + + AllRules.ruleset + + + + + + Disabled + include;$(SolutionDir)\include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + MultiThreadedDebugDLL + + + $(IntDir) + $(IntDir)vc90.pdb + $(IntDir) + Level3 + EditAndContinue + 4290;%(DisableSpecificWarnings) + + + $(TargetPath) + $(SolutionDir)lib\$(Configuration)\ + libcalc2dmath.lib + + + + + X64 + + + Disabled + include;$(SolutionDir)\include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + MultiThreadedDebugDLL + + + $(IntDir) + $(IntDir)vc90.pdb + $(IntDir) + Level3 + ProgramDatabase + 4290;%(DisableSpecificWarnings) + + + $(TargetPath) + $(SolutionDir)lib\$(Platform)\$(Configuration)\ + libcalc2dmath.lib + + + + + include;$(SolutionDir)\include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + MultiThreadedDLL + + + $(IntDir) + $(IntDir)vc90.pdb + $(IntDir) + Level3 + ProgramDatabase + + + $(TargetPath) + $(SolutionDir)lib\$(Configuration)\ + libcalc2dmath.lib + + + + + X64 + + + include;$(SolutionDir)\include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + MultiThreadedDLL + + + $(IntDir) + $(IntDir)vc90.pdb + $(IntDir) + Level3 + ProgramDatabase + + + $(TargetPath) + $(SolutionDir)lib\$(Platform)\$(Configuration)\ + libcalc2dmath.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/proj/libcalc2d/Calculation2D.vcxproj.filters b/proj/libcalc2d/Calculation2D.vcxproj.filters new file mode 100644 index 0000000..db4b807 --- /dev/null +++ b/proj/libcalc2d/Calculation2D.vcxproj.filters @@ -0,0 +1,213 @@ + + + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {dc45dcdb-97dd-4abd-8727-5b1b64bade58} + + + {f534c902-48c7-43ec-84dd-588d49756582} + + + {b741e4f8-6938-4dfd-99dd-8be396e0e8e4} + + + {5aede797-ab77-4d8d-8b8e-1c8a9b328c9e} + + + {621a138a-09d3-4093-9466-ba38ab70d61b} + + + {b0121389-a342-49bb-81bf-9c8296be7655} + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {d008bc18-972e-4846-b53e-f6f6cccbe2f5} + + + {b393c518-01ad-4742-942d-46bc49eae3ec} + + + {637739e5-1851-4aec-a0f0-a2755940c22d} + + + {36855bdd-24c0-4f23-bfee-ea4a61063a7a} + + + {cd5eadb5-036f-4273-bb12-9d9e71b1f834} + + + {b840c7a4-ea33-45ff-8ad9-73ff4e7d1bad} + + + + + Header Files\Calculation + + + Header Files\Calculation + + + Header Files\Calculation + + + Header Files\Calculation + + + Header Files\Images + + + Header Files\Log + + + Header Files\Log + + + Header Files\System + + + Header Files\System + + + Header Files\System + + + Header Files\System + + + Header Files\XML + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Interfaces + + + Header Files\Log + + + Header Files\System + + + Header Files\XML + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files\Images + + + + + Source Files + + + Source Files + + + Source Files\Images + + + Source Files\Images + + + Source Files\XML + + + Source Files\XML + + + Source Files\Log + + + Source Files\Log + + + Source Files\Log + + + Source Files\Calculation + + + Source Files\Calculation + + + Source Files\Calculation + + + Source Files\Calculation + + + Source Files\System + + + Source Files\System + + + Source Files\System + + + Source Files\System + + + Source Files\System + + + Source Files\Interfaces + + + Source Files\Interfaces + + + Source Files\Interfaces + + + Source Files\Interfaces + + + \ No newline at end of file diff --git a/proj/libcalc2d/include/fileio/mmFileIOStd.h b/proj/libcalc2d/include/fileio/mmFileIOStd.h new file mode 100644 index 0000000..81ca828 --- /dev/null +++ b/proj/libcalc2d/include/fileio/mmFileIOStd.h @@ -0,0 +1,316 @@ +//****************************************************************************** +//****************************************************************************** +// +// FileIO STD implementation +// +// +// Description: This header defines implementation of all interfaces from +// FileIO namespace. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmFileIOSTDH +#define mmFileIOSTDH + +#include + +#include +#include + +namespace mmFileIO +{ + //////////////////////////////////////////////////////////////////////////////// + /// Function returns current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @return file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFilePosition(std::ifstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @return file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFilePosition(std::wifstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @return file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFilePosition(std::ofstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @return file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFilePosition(std::wofstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function sets current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @param[in] p_iFilePos file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + void SetFilePosition(std::ifstream* p_psFile,mmInt p_iFilePos); + + //////////////////////////////////////////////////////////////////////////////// + /// Function sets current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @param[in] p_iFilePos file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + void SetFilePosition(std::wifstream* p_psFile,mmInt p_iFilePos); + + //////////////////////////////////////////////////////////////////////////////// + /// Function sets current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @param[in] p_iFilePos file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + void SetFilePosition(std::ofstream* p_psFile,mmInt p_iFilePos); + + //////////////////////////////////////////////////////////////////////////////// + /// Function sets current file position. + /// + /// @param[in] p_psFile pointer to file object + /// @param[in] p_iFilePos file position in bytes counted from beginning. + //////////////////////////////////////////////////////////////////////////////// + void SetFilePosition(std::wofstream* p_psFile,mmInt p_iFilePos); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns file length in bytes. + /// + /// @param[in] p_psFile pointer to file object + /// @return length of file in bytes. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFileLenght(std::ifstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns file length in bytes. + /// + /// @param[in] p_psFile pointer to file object + /// @return length of file in bytes. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFileLenght(std::wifstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns file length in bytes. + /// + /// @param[in] p_psFile pointer to file object + /// @return length of file in bytes. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFileLenght(std::ofstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// Function returns file length in bytes. + /// + /// @param[in] p_psFile pointer to file object + /// @return length of file in bytes. + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFileLenght(std::wofstream* p_psFile); + + //////////////////////////////////////////////////////////////////////////////// + /// This class implements mmFileIO::mmFileUtilsI interface with use of + /// C++ STD library. It defines functions supporting file/directory manipulation. + //////////////////////////////////////////////////////////////////////////////// + class mmFileUtilsSTD: public mmFileUtilsI, + mmLog::mmLogSender + { + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + /// @param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// + mmFileUtilsSTD(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmFileUtilsSTD(); + + void CreateDir(mmString p_sDirName); + void CreateDirStructure(mmString p_sDirName); + void ClearDir(mmString p_sDirName); + void RemoveDir(mmString p_sDirName,bool p_bWithElements); + + bool IsExistingDir(mmString p_sDirName); + mmString GetTemporaryDir(void); + mmString GetApplicationDir(void); + std::vector GetDirElements(mmString p_sDirName, + mmString p_sDirWildcards); + bool IsEmptyDir(mmString p_sDirName); + + void RemoveFile(mmString p_sFileName); + bool IsExistingFile(mmString p_sFileName); + mmString GetPathToFile(mmString p_sFileName); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// This class implements mmFileIO::mmTextFileReadI interface with use of + /// C++ STD library. + //////////////////////////////////////////////////////////////////////////////// + class mmTextFileReadSTD: public mmTextFileReadI, + mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to file object from STD library. + //////////////////////////////////////////////////////////////////////////////// + std::wifstream* m_psFile; + //////////////////////////////////////////////////////////////////////////////// + /// File name which is open. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sFileName; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Class constructor. + /// + /// @param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// + mmTextFileReadSTD(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmTextFileReadSTD(); + + void Open(mmString p_sFileName); + void Close(void); + bool ReadChar(wchar_t* p_pcChar); + bool ReadLine(mmString* p_psFileLine); + mmInt ReadLines(std::vector* p_psLines,mmInt p_iLinesCount); + mmInt GetLenght(void); + mmInt ReadWholeFile(wchar_t* p_pcFileContent); + bool Eof(void); + bool IsActiveFile(void); + mmInt GetActualFilePosition(void); + mmString GetFileName(void); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// This class implements mmFileIO::mmTextFileWriteI interface with use of + /// C++ STD library. + //////////////////////////////////////////////////////////////////////////////// + class mmTextFileWriteSTD: public mmTextFileWriteI, + mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// pointer to file object from STD library. + //////////////////////////////////////////////////////////////////////////////// + std::wofstream* m_psFile; + //////////////////////////////////////////////////////////////////////////////// + /// File name. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sFileName; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + ///`@param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// + mmTextFileWriteSTD(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmTextFileWriteSTD(); + + void Open(mmString p_sFileName, + eOpenFileMode p_eOpenMode); + void Close(void); + void WriteChar(wchar_t p_cChar); + void WriteLine(mmString p_sFileLine); + void WriteLines(std::vector* p_psLines); + void WriteBuffer(wchar_t const* p_pcBuffer,mmInt p_iBufferSize); + void WriteEol(void); + void Flush(void); + bool IsActiveFile(void); + mmString GetFileName(void); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// This class implements mmFileIO::mmBinaryFileReadI interface with use of + /// C++ STD library. + //////////////////////////////////////////////////////////////////////////////// + class mmBinaryFileReadSTD: public mmBinaryFileReadI, + mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to file object from STD library. + //////////////////////////////////////////////////////////////////////////////// + std::ifstream* m_psFile; + //////////////////////////////////////////////////////////////////////////////// + /// File name which is open. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sFileName; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Class constructor. + /// + /// @param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// + mmBinaryFileReadSTD(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmBinaryFileReadSTD(); + + void Open(mmString p_sFileName); + void Close(void); + bool ReadBuffer(void* p_pBuffer,mmInt p_iSize); + mmInt GetLenght(void); + bool Eof(void); + bool IsActiveFile(void); + mmInt GetActualFilePosition(void); + void SetActualFilePosition(mmInt p_iFilePos); + mmString GetFileName(void); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// This class implements mmFileIO::mmBinaryFileWriteI interface with use of + /// C++ STD library. + //////////////////////////////////////////////////////////////////////////////// + class mmBinaryFileWriteSTD: public mmBinaryFileWriteI, + mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// pointer to file object from STD library. + //////////////////////////////////////////////////////////////////////////////// + std::ofstream* m_psFile; + //////////////////////////////////////////////////////////////////////////////// + /// File name. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sFileName; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + ///`@param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// + mmBinaryFileWriteSTD(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmBinaryFileWriteSTD(); + + void Open(mmString p_sFileName, + mmFileIO::eOpenFileMode p_eOpenMode); + void Close(void); + bool WriteBuffer(void* p_pBuffer,mmInt p_iSize); + mmInt GetLenght(void); + bool IsActiveFile(void); + mmInt GetActualFilePosition(void); + void SetActualFilePosition(mmInt p_iFilePos); + mmString GetFileName(void); + void Flush(void); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/images/mmImagesCalculationManagement.h b/proj/libcalc2d/include/images/mmImagesCalculationManagement.h new file mode 100644 index 0000000..f9d182f --- /dev/null +++ b/proj/libcalc2d/include/images/mmImagesCalculationManagement.h @@ -0,0 +1,65 @@ +//****************************************************************************** +//****************************************************************************** +// +// Images calculation management class +// +// +// Description: This header defines mmImages calculation management class +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmIImagesCalculationManagementH +#define mmIImagesCalculationManagementH + +#include +#include +#include +#include + +namespace mmImages +{ + + + //////////////////////////////////////////////////////////////////////////////// + /// Class for images calculation management. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesCalculationManagement: public mmLog::mmLogSender, public mmThread::mmThreadExecutionI + { + private: + bool m_bIsActiveCalculation; + + + mmImages::mmImageStructureI* m_psImageStructure; + std::vector m_vRunningThreads; + mmInt m_iCalculationThreadCount; + + // control thread + bool m_bTerminateControlThreadExecution; + mmThread::mmThreadI* m_psControlThread; + mmInt m_iThreadExecutionSleepTime; + mmReal m_rProgress; + private: + void StopRunningThreads(void); + public: + mmImagesCalculationManagement(mmInt p_iCalcThreadCount, mmLog::mmLogReceiverI *p_psLogReceiver); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmImagesCalculationManagement(); + + void CalculateImages(mmImages::mmImagesCalculationMethodI* p_psImagesCalculationMethod, mmImages::mmImageStructureI* p_psImageStructure, + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams = NULL); + + bool IsCalculating(void); + + bool Execute(void); + void StopExecution(void); + bool IsExecuting(void); + mmReal GetProgress(void); + + void UserAction(mmString p_sXMLParams); + void UserAction(wchar_t* p_pcXMLParamsBuffer, mmInt p_iXMLParamsBufferSize); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/images/mmImagesCalculationMethodContainerWindows.h b/proj/libcalc2d/include/images/mmImagesCalculationMethodContainerWindows.h new file mode 100644 index 0000000..c7d81c6 --- /dev/null +++ b/proj/libcalc2d/include/images/mmImagesCalculationMethodContainerWindows.h @@ -0,0 +1,95 @@ +//****************************************************************************** +//****************************************************************************** +// +// images calculation method Container for Windows OS class +// +// +// Description: This header defines implementation of +// mmImages::mmImagesCalculationMethodContainerI interface +// for Windows OS using dlls. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmImagesCalculationMethodContainerForWindowsOSH +#define mmImagesCalculationMethodContainerForWindowsOSH + +#include +#include + + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of function type returning number of supported images +/// calculation method types. +//////////////////////////////////////////////////////////////////////////////// +typedef mmInt (__stdcall *mmDLLGetSupportedImagesCalculationMethodCount)(void); + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of function type returning structure +/// mmImages::mmImagesCalculationMethodI::sCalculationMethodParams +/// defining supported images calculation method. +//////////////////////////////////////////////////////////////////////////////// +typedef mmImages::mmImagesCalculationMethodI::sCalculationMethodParams (__stdcall *mmDLLGetSupportedImagesCalculationMethodDef)(mmInt); + +namespace mmImages +{ + //////////////////////////////////////////////////////////////////////////////// + /// Implementation of mmImages::mmImagesCalculationMethodContainerI interface for + /// windows operating system with using of dll loading. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesCalculationMethodContainerForWindows: public mmImagesCalculationMethodContainerI, + mmLog::mmLogSender + { + private: // definitions + //////////////////////////////////////////////////////////////////////////////// + /// Structure defining dll with images calculation method definition. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// DLL name with full path. + //////////////////////////////////////////////////////////////////////////////// + mmString sDLLName; + //////////////////////////////////////////////////////////////////////////////// + /// Definition of images calculation method supported by this DLL. + //////////////////////////////////////////////////////////////////////////////// + std::vector vImagesCalculationMethodDefs; + } sImagesCalculationMethodInDLL; + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// This vector stores available Images calculation method definitions. + //////////////////////////////////////////////////////////////////////////////// + std::vector m_vAvailableDLLs; + + private: // methods + //////////////////////////////////////////////////////////////////////////////// + /// This method fills all DLLs stored in application directory into m_vAvailableDLLs + /// structure. + //////////////////////////////////////////////////////////////////////////////// + void SearchForDLLLibraries(void); + //////////////////////////////////////////////////////////////////////////////// + /// This method searches for DLLs supporting images calculation method + /// interface and writes found calculation method names into m_vAvailableDLLs + /// structure. + //////////////////////////////////////////////////////////////////////////////// + void SearchForImagesCalculationMethodsInDLLLibraries(void); + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + /// @param[in] p_psMainWindow pointer to main window object + /// @param[in] p_psLogReceiver pointer to log object + //////////////////////////////////////////////////////////////////////////////// + mmImagesCalculationMethodContainerForWindows(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmImagesCalculationMethodContainerForWindows(); + + std::vector GetAvailableImagesCalculationMethods(void); + mmImages::mmImagesCalculationMethodI* InitializeImagesCalculationMethod(mmString p_sCalculationMethodName); + }; +}; + +#endif + diff --git a/proj/libcalc2d/include/images/mmImagesCalculationMethodDLLBroker.h b/proj/libcalc2d/include/images/mmImagesCalculationMethodDLLBroker.h new file mode 100644 index 0000000..7876f10 --- /dev/null +++ b/proj/libcalc2d/include/images/mmImagesCalculationMethodDLLBroker.h @@ -0,0 +1,85 @@ +//****************************************************************************** +//****************************************************************************** +// +// DLL images Calculation Method Broker class +// +// +// Description: This header defines implementation of +// mmImages::mmImagesCalculationMethodI interface for broker +// functionality between main application and DLL code +// (it is required because STL library fails in DLL). +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmImagesCalculationMethodDLLBrokerH +#define mmImagesCalculationMethodDLLBrokerH + +#include +#include + +#include + +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of function type returning initialised specified images +/// calculation method. +//////////////////////////////////////////////////////////////////////////////// +typedef mmImages::mmImagesCalculationMethodI* (__stdcall *mmDLLImagesCalculationMethod_Create)(mmInterfacesStorage::mmGlobalInterfacesStorage*,const wchar_t*); + +//////////////////////////////////////////////////////////////////////////////// +/// Definition of function type freeing images calculation method object. +//////////////////////////////////////////////////////////////////////////////// +typedef void (__stdcall *mmDLLImagesCalculationMethod_Destroy)(mmImages::mmImagesCalculationMethodI*); + +namespace mmImages +{ + //////////////////////////////////////////////////////////////////////////////// + /// Implementation of mmImages::mmImagesCalculationMethodI interface for + /// DLL broker. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesCalculationMethodDLLBroker: public mmImagesCalculationMethodI, + public mmLog::mmLogSender + { + private: // fields + HINSTANCE m_hDLLHandle; + mmImages::mmImagesCalculationMethodI* m_psInitializedImagesCalculationMethod; + + + mmDLLImagesCalculationMethod_Create m_psDLLImagesCalculationMethod_Create; + mmDLLImagesCalculationMethod_Destroy m_psDLLImagesCalculationMethod_Destroy; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + /// @param[in] p_sDLLName name of DLL with images calculation method + /// definition + /// @param[in] p_sImagesCalculationMethodName name of images + /// calculation method to initialize + /// @param[in] p_psLogReceiver pointer to log object + //////////////////////////////////////////////////////////////////////////////// + mmImagesCalculationMethodDLLBroker(mmString p_sDLLName, mmString p_sImagesCalculationMethodName, + mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmImagesCalculationMethodDLLBroker(); + + mmImages::mmImagesCalculationMethodI::sCalculationMethodParams GetCalculationMethodInfo(void); + void SetCalculationMethodParameters(mmImages::mmImageStructureI* p_psImageStructure, + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams = NULL); + + void UserAction(mmString p_sXMLParams); + void UserAction(wchar_t* p_pcXMLParamsBuffer, + mmInt p_iXMLParamsBufferSize); + + bool Execute(void); + void StopExecution(void); + bool IsExecuting(void); + mmReal GetProgress(void); + }; +}; + +#endif + diff --git a/proj/libcalc2d/include/images/mmImagesComplexCalculationManagement.h b/proj/libcalc2d/include/images/mmImagesComplexCalculationManagement.h new file mode 100644 index 0000000..9d76cb4 --- /dev/null +++ b/proj/libcalc2d/include/images/mmImagesComplexCalculationManagement.h @@ -0,0 +1,262 @@ +//****************************************************************************** +//****************************************************************************** +// +// Images complex calculation management class +// +// Description: This header defines mmImages complex calculation management class +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmImagesComplexCalculationManagementH +#define mmImagesComplexCalculationManagementH + +#include +#include + +#include +#include +#include +#include +#include + +namespace mmImages +{ + extern const wchar_t* g_pComplexCalcXML_PatternContainer_Node; + + extern const wchar_t* g_pComplexCalcXML_Pattern_Node; + extern const wchar_t* g_pComplexCalcXML_PatternName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternIDName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternDescription_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInputParams_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInputParam_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInputParam_Constant_Attr; + extern const wchar_t* g_pComplexCalcXML_PatternInputParamName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInputParamType_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInputParamValue_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInputParamValueModifiedNodeName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParams_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParam_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParamName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParamType_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParamValue_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParamValueModifiedNodeName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParamValueModifiedSecondNodeName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternOutputParamOperation_Node; + extern const wchar_t* g_pComplexCalcXML_PatternDefinition_Node; + extern const wchar_t* g_pComplexCalcXML_PatternCalcMethod_Node; + extern const wchar_t* g_pComplexCalcXML_PatternCalcMethodIDName_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInternalAction_Node; + extern const wchar_t* g_pComplexCalcXML_PatternInternalActionName_Node; + +// PB // +// extern const wchar_t* g_pComplexCalcXML_Action_AddSimpleCalculationMethod; +// extern const wchar_t* g_pComplexCalcXML_Action_AddOutputValueFromExisting; +// extern const wchar_t* g_pComplexCalcXML_Action_MixOutputValuesFromExisting; +// extern const wchar_t* g_pComplexCalcXML_Action_AddInputValueFromExistingOrConst; +// extern const wchar_t* g_pComplexCalcXML_Action_AddInputValueConstDecision; +// extern const wchar_t* g_pComplexCalcXML_Action_CreateSimplifiedCloudStructure; +// extern const wchar_t* g_pComplexCalcXML_Action_DeleteSimplifiedCloudStructure; + +// PB // +// extern const wchar_t* g_pComplexCalcXML_Action_AddWhileLoop; +// extern const wchar_t* g_pComplexCalcXML_Action_AddEndWhile; +// extern const wchar_t* g_pComplexCalcXML_Action_CopyBinaryOutputToInputValue; +// extern const wchar_t* g_pComplexCalcXML_Action_CopyIntOutputToInputValue; +// extern const wchar_t* g_pComplexCalcXML_Action_CopyRealOutputToInputValue; + +// PB // +// extern const wchar_t* g_pComplexCalcXML_PatternInputParamUserSpecified; +// extern const wchar_t* g_pComplexCalcXML_PatternInputParamConstant_Real; +// extern const wchar_t* g_pComplexCalcXML_PatternInputParamConstant_Int; + + + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Addition; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Subtraction; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Multiplication; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Division; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Power; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Minimum; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Maximum; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Equal; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Less; + extern const wchar_t* g_pComplexCalcXML_PatternOutputFormula_Greater; + + //////////////////////////////////////////////////////////////////////////////// + /// Interface for images complex calculation management change receiver. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesComplexCalculationManagementStateChangeReceiverI + { + public: + //////////////////////////////////////////////////////////////////////////////// + /// Virtual destructor. + //////////////////////////////////////////////////////////////////////////////// + virtual ~mmImagesComplexCalculationManagementStateChangeReceiverI() {}; + + virtual void StartOfComplexCalculation(void) = 0; + virtual void StopOfComplexCalculation(void) = 0; + + virtual void ListOfComplexCalculationPatternsUpdated(void) = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Class for images complex calculation management. + //////////////////////////////////////////////////////////////////////////////// + class mmImagesComplexCalculationManagement: public mmLog::mmLogSender, + public mmThread::mmThreadExecutionI + { + public: // defs + typedef struct + { + mmString sName; + mmString sIDName; + mmString sDescription; + } sComplexCalculationInfo; + private: // defs + typedef struct + { + mmString sIDName; + mmImages::mmImageStructureI* psImageStructure; + } sComplexCalculationDefinition; + private: + bool m_bIsActiveCalculation; + mmImages::mmImagesCalculationMethodContainerI* m_psImageCalculationMethodContainer; + mmImages::mmImageStructureI* m_psImageStructure; + mmImages::mmImagesCalculationManagement* m_psImageCalculationManagement; + + // control thread + bool m_bTerminateControlThreadExecution; + mmThread::mmThreadI* m_psControlThread; + mmInt m_iThreadExecutionSleepTime; + + // structures with information about simple calculation methods + std::vector m_vSimpleCalculationMethodsInfo; + + // XML with new pattern definition + mmXML::mmXMLDocI* m_psXMLCurrentPatternDefinition; + bool m_bIsNew; + + // XML with complex patterns container + mmXML::mmXMLDocI* m_psXMLComplexPatternContainer; + mmString m_sComplexPatternContainerXMLFile; + + // state change receiver + mmImagesComplexCalculationManagementStateChangeReceiverI* m_psStateChangeReceiver; + + // execution queue + std::deque m_vCalculationSheme; + mmSynchronize::mmExclusiveLockI* m_psThreadSynchronizationEL; + + // simplified clouds stack + std::stack m_vSimplifiedImage; + + // XML with currently calculated pattern definition + mmXML::mmXMLNodeI* m_psXMLCalculatedPatternDefinition; + sComplexCalculationDefinition m_sCurrentComplexCalculation; + mmImages::mmImagesCalculationMethodI* m_psCurrentCalculationMethod; + mmInt m_iCurrentComplexCalculationItem; + private: +// PB // +// mmString CreateComplexCalculationPatternUI( mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition, +// bool p_bIsReadOnly); +// mmString GetFromUIDefinitionForSingleCalculationMethod( mmString p_sCalculationMethodIDName, +// bool* p_pbNoParams); + +// PB // +// mmImages::mmImagesCalculationMethodI::sCalculationMethodParams* GetCalculationMethodInfo(mmString p_sCalculationMethodIDName); +// mmString GetCalculationMethodName(mmString p_sCalculationMethodIDName); + +// PB // +// mmString UpdateInputOutputParameters(mmString p_psInOutParams); + +// PB // +// mmString GetFromUIReadableInputParameterName( mmString p_sTitle, +// mmString p_sDescription, +// mmString p_sParamName); + +// PB // +// mmString CreateNewOutputValueFromExistingUI(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); +// mmString CreateNewOutputValueFromMixOfTwoExistingUI(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); +// mmString CreateNewConstantInputValueUI(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); +// mmString CreateNewConstantInputDecisionUI(void); + +// PB // +// void AddSingleCalculationMethodIntoPattern( mmString p_sCalculationMethodParams, +// mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); + + void LoadComplexPatternsFromFile(mmString p_sCPFile); +// PB // +// void SaveComplexPatternsIntoFile(mmString p_sCPFile); +// void AddComplexPatternIntoContainer(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); +// void UpdateComplexPatternInContainer(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); + + mmXML::mmXMLNodeI* GetComplexCalculationPatternDefinition(mmString p_sCCPIDName); + + mmXML::mmXMLNodeI* GetInputParamsOfCCPattern(mmString p_sCCPIDName); + mmXML::mmXMLNodeI* GetOutputParamsOfCCPattern(mmString p_sCCPIDName); + +// PB // +// void AddInternalWHILELoop(void); +// void AddInternalENDWHILELoop(void); +// void AddInternalCopyBinaryOutToInVariable(void); +// void AddInternalCopyIntOutToInVariable(void); +// void AddInternalCopyRealOutToInVariable(void); +// mmString GetUIDefinitionForInternalAction( mmString p_sInternalActionName, +// mmString p_sIAInParams, +// mmString p_sIAOutParams, +// bool* p_pbNoParams); +// mmString GetUIDefinitionForMultiSelectValues(mmString p_sUIData); +// void AddInternalMethodIntoPattern( mmString p_sInOutParams, +// mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition); + +// PB // +// void InitializeCurrentComplexCalculationPatternExecution(void); + + bool ManageCurrentComplexCalculationPatternExecution(void); +// PB // +// void GetComplexCalculationPatternInputParamsFromUI(mmXML::mmXMLNodeI* p_psComplexCalculationDefinition); + + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams InitializeParamsOfSimpleCalculationMethod( mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmInt p_iCalculationMethodToInitializeID); +// PB // + void UpdateOutputParamsOfSimpleCalculationMethod( mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmInt p_iCalculationMethodToUpdateID); + + mmString GetValueOfParameter(mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmString p_sParamName); + void SetValueOfParameter(mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmString p_sParamName, + mmString p_sParamValue); + + public: + mmImagesComplexCalculationManagement( mmImages::mmImagesCalculationMethodContainerI* p_psImageCalculationMethodContainer, + mmImages::mmImagesCalculationManagement* p_psImageCalculationManagement, + mmLog::mmLogReceiverI *p_psLogReceiver); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmImagesComplexCalculationManagement(); + + mmInt GetCountOfComplexCalculationPatterns(void); + mmImages::mmImagesComplexCalculationManagement::sComplexCalculationInfo GetComplexCalculationPatternInfo(mmInt p_iPatternID); + + void ExecuteComplexCalculationPattern( mmString p_sPatternIDName, + mmImages::mmImageStructureI* p_psImageStructure); + + void RegisterStateChangeReceiver(mmImagesComplexCalculationManagementStateChangeReceiverI* p_psStateChangeReceiver); + void UnregisterStateChangeReceiver(mmImagesComplexCalculationManagementStateChangeReceiverI* p_psStateChangeReceiver); + + bool IsCalculating(void); + + bool Execute(void); + void StopExecution(void); + bool IsExecuting(void); + mmReal GetProgress(void); + + mmString GetInputParamsOfComplexCalculationPattern(mmString p_sCCPIDName); + mmString GetOutputParamsOfComplexCalculationPattern(mmString p_sCCPIDName); + mmString SetInputParamsOfComplexCalculationPattern(mmString p_sCCPIDName, mmString p_sNewParams); + mmString SetOutputParamsOfComplexCalculationPattern(mmString p_sCCPIDName, mmString p_sNewParams); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/images/mmImagesStructure.h b/proj/libcalc2d/include/images/mmImagesStructure.h new file mode 100644 index 0000000..39728a0 --- /dev/null +++ b/proj/libcalc2d/include/images/mmImagesStructure.h @@ -0,0 +1,136 @@ +//****************************************************************************** +//****************************************************************************** +// +// Images implementation +// +// Autor: Maciek Karaszewski +// Version: 2009.09.09 +// +// Description: This header defines implementation of +// mmImages::mmImagesStructure +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmImagesStructureH +#define mmImagesStructureH + +#include +#include +#include + +#include + +namespace mmImages +{ + class mmLayer : public mmLayerI { + public: + mmLayer(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmReal const p_rDefaultValue, mmCallbackI * const p_psCallback); + ~mmLayer(void); + public: + void Resize(mmUInt const p_iWidth, mmUInt const p_iHeight); + public: // mmLayerI implementation + virtual mmUInt GetWidth(void) const; + virtual mmUInt GetHeight(void) const; + virtual mmReal GetDefaultValue(void) const; + + virtual mmStats GetStats(void) const; + + virtual mmString GetName(void) const; + virtual void SetName(mmString const & p_sName); + + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmReal p_prValues[]) const; + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmReal const p_prValues[]); + + virtual bool GetPixels(mmRect const & p_sRect, mmReal p_prValues[]) const; + virtual bool SetPixels(mmRect const & p_sRect, mmReal const p_prValues[]); + private: + mmUInt m_iWidth; + mmUInt m_iHeight; + mmString m_sName; + mmReal m_rDefaultValue; + mmReal * m_prValues; + mmStats m_sStats; + mmCallbackI * const m_psCallback; + mmSynchronize::mmReadWriteLockI * const m_psLock; + }; + + class mmImage : public mmImageI, private mmLayerI::mmCallbackI { + public: + mmImage(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmPixelType const p_ePixelType, mmImageI::mmCallbackI * const p_psCallback); + ~mmImage(void); + public: // mmImageI implementation + virtual mmUInt GetWidth(void) const; + virtual mmUInt GetHeight(void) const; + virtual void Resize(mmUInt const p_iWidth, mmUInt const p_iHeight); + + virtual mmPixelType GetPixelType(void) const; + + virtual mmString GetName(void) const; + virtual void SetName(mmString const & p_sName); + + virtual mmLayerI * GetChannel(mmUInt const p_iIndex) const; + + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel8 p_psValues[]) const; + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel24 p_psValues[]) const; + virtual bool GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel32 p_psValues[]) const; + + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel8 const p_psValues[]); + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel24 const p_psValues[]); + virtual bool SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel32 const p_psValues[]); + + virtual bool GetPixels(mmRect const & p_sRect, mmPixel8 p_psValues[]) const; + virtual bool GetPixels(mmRect const & p_sRect, mmPixel24 p_psValues[]) const; + virtual bool GetPixels(mmRect const & p_sRect, mmPixel32 p_psValues[]) const; + + virtual bool SetPixels(mmRect const & p_sRect, mmPixel8 const p_psValues[]); + virtual bool SetPixels(mmRect const & p_sRect, mmPixel24 const p_psValues[]); + virtual bool SetPixels(mmRect const & p_sRect, mmPixel32 const p_psValues[]); + + virtual void SetRegionOfInterest(mmRect const & p_sRegion); + virtual mmRect GetRegionOfInterest(void) const; + + virtual mmUInt CreateLayer(mmString const & p_sName, mmReal const p_rDefaultValue); + virtual mmUInt GetLayerCount(void) const; + virtual mmLayerI * GetLayer(mmUInt const p_iIndex) const; + virtual mmLayerI * GetLayer(mmString const & p_sName) const; + virtual bool DeleteLayer(mmUInt const p_iIndex); + virtual bool DeleteLayer(mmString const & p_sName); + + virtual void SetMetadata(mmString const & p_sMetadata); + virtual mmString GetMetadata(void); + private: // mmLayerI::mmCallbackI implementation + virtual void OnLayerCreate(mmLayerI * p_psLayer); + virtual void OnLayerDestroy(mmLayerI * p_psLayer); + virtual void OnLayerPropertiesChange(mmLayerI * p_psLayer); + virtual void OnLayerValuesChange(mmLayerI * p_psLayer); + private: + mmUInt m_iWidth; + mmUInt m_iHeight; + mmString m_sName; + mmPixelType m_ePixelType; + std::list m_sChannels; + std::list m_sLayers; + mmRect m_sRegionOfInterest; + mmString m_sMetadata; + mmImageI::mmCallbackI * const m_psCallback; + }; + + class mmImageStructure : public mmImageStructureI { + public: + mmImageStructure(mmImageI::mmCallbackI * const p_psCallback); + ~mmImageStructure(void); + public: // mmImageStructureI implementation + virtual mmUInt CreateImage(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmImageI::mmPixelType const p_ePixelType); + virtual mmUInt GetImageCount(void) const; + virtual mmImageI * GetImage(mmUInt const p_iIndex) const; + virtual mmImageI * GetImage(mmString const & p_sName) const; + virtual bool DeleteImage(mmUInt const p_iIndex); + virtual bool DeleteImage(mmString const & p_sName); + private: + std::list m_sImages; + mmImageI::mmCallbackI * m_psCallback; + }; +}; + +#endif + diff --git a/proj/libcalc2d/include/log/mmLogFile.h b/proj/libcalc2d/include/log/mmLogFile.h new file mode 100644 index 0000000..d4b2b38 --- /dev/null +++ b/proj/libcalc2d/include/log/mmLogFile.h @@ -0,0 +1,46 @@ +//****************************************************************************** +//****************************************************************************** +// +// Log File class +// +// +// Description: This class implements interface mmLogReceiverI and it supports +// file logging. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmLogFileH +#define mmLogFileH + +#include +#include + +namespace mmLog +{ + //////////////////////////////////////////////////////////////////////////////// + /// Implementation of log receiver interface for file logging. + //////////////////////////////////////////////////////////////////////////////// + class mmLogFile: public mmLogReceiverI + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to file object where log information is stored. + //////////////////////////////////////////////////////////////////////////////// + mmFileIO::mmTextFileWriteI* m_psLogFile; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + /// @param[in] p_sLogFileName name of log file to open + //////////////////////////////////////////////////////////////////////////////// + mmLogFile(mmString p_sLogFileName); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmLogFile(); + + void SendLogMessage(eLogMessagePriority p_ePriority,mmString* p_psString); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/log/mmLogRedirector.h b/proj/libcalc2d/include/log/mmLogRedirector.h new file mode 100644 index 0000000..ea043f4 --- /dev/null +++ b/proj/libcalc2d/include/log/mmLogRedirector.h @@ -0,0 +1,102 @@ +//****************************************************************************** +//****************************************************************************** +// +// Log Redirector class +// +// +// Description: This class is used for redirecting log messages from the +// system to log receivers clients like console, file, network +// log server, etc. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmLogRedirectorH +#define mmLogRedirectorH + +#include + +#include +#include +#include + +namespace mmLog +{ + //////////////////////////////////////////////////////////////////////////////// + /// Implements interface mmLog::mmLogReceiverI. It allows to register many log + /// receivers with their own log priorities. When redirector receive a log + /// message then it sends this message to all registered receivers. + //////////////////////////////////////////////////////////////////////////////// + class mmLogRedirector: public mmLogReceiverI + { + private: // definitions + //////////////////////////////////////////////////////////////////////////////// + /// Structure defining log receiver to forward log messages into. + //////////////////////////////////////////////////////////////////////////////// + typedef struct + { + //////////////////////////////////////////////////////////////////////////////// + /// Lowest priority for messages received by pReceiver object. + //////////////////////////////////////////////////////////////////////////////// + eLogMessagePriority ePriority; + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to log receiver object, if NULL then receiver is not active. + //////////////////////////////////////////////////////////////////////////////// + mmLogReceiverI* pReceiver; + } sLogReceiver; + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Vector with registered log receivers. + //////////////////////////////////////////////////////////////////////////////// + std::vector m_sReceiverTable; + //////////////////////////////////////////////////////////////////////////////// + /// Synchronize log redirector work. + //////////////////////////////////////////////////////////////////////////////// + mmSynchronize::mmExclusiveLockI* m_psExclusiveLock; + private: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Checks if p_pLogReceiver is registered already. + /// + /// @param[in] p_pLogReceiver pointer to log receiver object to check + /// @return TRUE if is registered already, FALSE otherwise. + //////////////////////////////////////////////////////////////////////////////// + bool IsRegistered(mmLogReceiverI* p_pLogReceiver); + //////////////////////////////////////////////////////////////////////////////// + /// Returns index with free field in m_sReceiverTable, if there is no free place + /// it creates new one and return its index. + /// + /// @return index of free field + //////////////////////////////////////////////////////////////////////////////// + mmInt GetFreeReceiverTableIndex(void); + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + //////////////////////////////////////////////////////////////////////////////// + mmLogRedirector(); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmLogRedirector(); + + //////////////////////////////////////////////////////////////////////////////// + /// Method registers new class for receiving log messages. If object is already + /// registered then throws mmError(mmeLogReceiverObjectAlreadyRegistered). + /// + /// @param[in] p_eMinPriority minimal priority of received messages for this log + /// receiver object + /// @param[in] p_pLogReceiver pointer to log object + //////////////////////////////////////////////////////////////////////////////// + void RegisterLogReceiver(eLogMessagePriority p_eMinPriority, + mmLogReceiverI* p_pLogReceiver); + //////////////////////////////////////////////////////////////////////////////// + /// Unregisters log receiver object. If object is not registered throws + /// mmError(mmeLogReceiverObjectIsNotRegistered). + /// + /// @param[in] p_pLogReceiver pointer to log receiver. + //////////////////////////////////////////////////////////////////////////////// + void UnregisterLogReceiver(mmLogReceiverI* p_pLogReceiver); + + void SendLogMessage(eLogMessagePriority p_ePriority,mmString* p_psString); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/synchronize/mmSynchronizeWindowsImpl.h b/proj/libcalc2d/include/synchronize/mmSynchronizeWindowsImpl.h new file mode 100644 index 0000000..d15ebde --- /dev/null +++ b/proj/libcalc2d/include/synchronize/mmSynchronizeWindowsImpl.h @@ -0,0 +1,101 @@ +//****************************************************************************** +//****************************************************************************** +// +// Synchronization implementation for Windows systems +// +// +// Description: Implementation of synchronization behavior for Windows +// operating systems basing on CriticalSection +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmSynchronizeWindowsImplH +#define mmSynchronizeWindowsImplH + +#include + +#include +#include + +namespace mmSynchronize +{ + //////////////////////////////////////////////////////////////////////////////// + /// Implements interface mmExclusiveLockI. It uses Windows CRITICAL_SECTION. + //////////////////////////////////////////////////////////////////////////////// + class mmExclusiveLockCSWindows: public mmExclusiveLockI, mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Windows critical section. + //////////////////////////////////////////////////////////////////////////////// + CRITICAL_SECTION m_sCriticalSection; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Contructor initializes critical section object. + /// + /// @param[in] p_psLogReceiver pointer to mmLogReceiverI object. + //////////////////////////////////////////////////////////////////////////////// + mmExclusiveLockCSWindows(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. In case of unlocked state throws error + /// mmError(mmeExclusiveLockUnlocked). + //////////////////////////////////////////////////////////////////////////////// + ~mmExclusiveLockCSWindows(); + + virtual bool TryLock(void); + virtual void Lock(void); + virtual void Unlock(void); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Implements interface mmReadWriteLockI. It uses mmExclusiveLockCSWindows + /// and supports functionality for multiple reads and single exclusive write. + //////////////////////////////////////////////////////////////////////////////// + class mmReadWriteLockCSWindows: public mmReadWriteLockI, mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to m5ExclusiveLockI object. This object is used for synchronizing + /// state of m_iReadWriteCount counter. + //////////////////////////////////////////////////////////////////////////////// + mmExclusiveLockI* m_psExclusiveLock; + //////////////////////////////////////////////////////////////////////////////// + /// Counter for synchronization state: = -1 - locked for write + /// = 0 - unlocked + /// = n - locked for read by n-threads + //////////////////////////////////////////////////////////////////////////////// + mmInt m_iReadWriteCount; + //////////////////////////////////////////////////////////////////////////////// + /// Defines if any object waits for write access (TRUE) or not (FALSE). + /// If TRUE then other objects waiting for read access are stopped. + //////////////////////////////////////////////////////////////////////////////// + bool m_bWaitForWriteLock; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor initializes state of object. If allocation error occurs + /// then throws exception mmError(mmeBadAlloc). + /// + ///@param[in] p_psLogReceiver pointer to mmLogReceiverI object. + //////////////////////////////////////////////////////////////////////////////// + mmReadWriteLockCSWindows(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor deinitialize m_psExclusiveLock object. In case of bad end + /// conditions throws exception (if m_iReadWriteCount!=0 then throws + /// mmError(mmeReadWriteLockBadEndLockCount), if m_bWaitForWriteLock=true then + /// throws mmError(mmeReadWriteLockWaitForWrite)). + //////////////////////////////////////////////////////////////////////////////// + ~mmReadWriteLockCSWindows(); + + virtual bool TryLockForRead(void); + virtual void LockForRead(void); + virtual void UnlockFromRead(void); + + virtual bool TryLockForWrite(void); + virtual void LockForWrite(void); + virtual void UnlockFromWrite(void); + + virtual mmInt GetLockState(bool* p_pbWaitForWrite); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/thread/mmThreadWindowsImpl.h b/proj/libcalc2d/include/thread/mmThreadWindowsImpl.h new file mode 100644 index 0000000..98a731c --- /dev/null +++ b/proj/libcalc2d/include/thread/mmThreadWindowsImpl.h @@ -0,0 +1,82 @@ +//****************************************************************************** +//****************************************************************************** +// +// Thread class (Windows implementation) +// +// +// Description: Implementation of mmThreadI for Windows operating systems. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmThreadWindowsImplH +#define mmThreadWindowsImplH + +#include + +#include + +#include +#include +#include + +namespace mmThread +{ + //////////////////////////////////////////////////////////////////////////////// + /// This class implements mmThreads::mmThreadI interface. It uses Windows API. + //////////////////////////////////////////////////////////////////////////////// + class mmThreadWindows: public mmThreadI, mmLog::mmLogSender + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Windows thread handle. + //////////////////////////////////////////////////////////////////////////////// + HANDLE m_hWinThreadHandle; + //////////////////////////////////////////////////////////////////////////////// + /// Thread state. + //////////////////////////////////////////////////////////////////////////////// + eStatus m_eThreadStatus; + //////////////////////////////////////////////////////////////////////////////// + /// Pointer to object with implementation mmThreadExecutionI which perform + /// thread calculation. + //////////////////////////////////////////////////////////////////////////////// + mmThreadExecutionI* m_psThreadExecutionClass; + //////////////////////////////////////////////////////////////////////////////// + /// Synchronize object for thread data. + //////////////////////////////////////////////////////////////////////////////// + mmSynchronize::mmExclusiveLockI* m_psExclusiveLock; + private: // methods + //////////////////////////////////////////////////////////////////////////////// + /// This method is always called during new thread creation. It calls + /// ThreadExecute method for mmThreadWindows object pointed by + /// p_pThreadClassPointer pointer. + /// + /// @param[in] p_pThreadClassPointer pointer to mmThreadWindows object + /// @return state of thread. + //////////////////////////////////////////////////////////////////////////////// + static DWORD WINAPI ThreadRedirectFunction(LPVOID p_pThreadClassPointer); + //////////////////////////////////////////////////////////////////////////////// + /// This method is called by ThreadRedirectFunction for call Execute method + /// from mmThreadExecutionI object stored in m_psThreadExecutionClass. + //////////////////////////////////////////////////////////////////////////////// + void ThreadExecute(void); + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. In case of allocation error it throws mmError(mmeBadAlloc). + /// + /// @param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// + mmThreadWindows(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmThreadWindows(); + + void RegisterThreadExecutionClass(mmThreadExecutionI* p_psThreadExecutionObject); + void Run(void); + void Stop(void); + eStatus GetStatus(void); + mmReal GetProgress(void); + }; +}; + +#endif diff --git a/proj/libcalc2d/include/windows/mmDllSupport.h b/proj/libcalc2d/include/windows/mmDllSupport.h new file mode 100644 index 0000000..10caab6 --- /dev/null +++ b/proj/libcalc2d/include/windows/mmDllSupport.h @@ -0,0 +1,32 @@ +//****************************************************************************** +//****************************************************************************** +// +// DLL support for Windows OS class +// +// +// Description: This header defines useful functions for Windows OS using dlls. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmDLLSupportForWindowsOSH +#define mmDLLSupportForWindowsOSH + +#include + +namespace mmDLLSupport +{ + //////////////////////////////////////////////////////////////////////////////// + /// This function searches in DLL export table for specified symbol and returns + /// full exported symbol. + /// + /// @param[in] p_sDLLName DLL name with full path + /// @param[in] p_sName name of symbol + /// @return full name of symbol in DLL export table + //////////////////////////////////////////////////////////////////////////////// + mmString FindSymbolInDLLExportTable(mmString p_sDLLName, + mmString p_sName); +}; + +#endif + + diff --git a/proj/libcalc2d/include/xml/mmXMLBB.h b/proj/libcalc2d/include/xml/mmXMLBB.h new file mode 100644 index 0000000..d424075 --- /dev/null +++ b/proj/libcalc2d/include/xml/mmXMLBB.h @@ -0,0 +1,217 @@ +//****************************************************************************** +//****************************************************************************** +// +// MSXML2 XML implementation +// +// Description: These classes implement functionality of wotking with XML files +// and data. +// +//****************************************************************************** +//****************************************************************************** +#ifndef mmXMLBBH +#define mmXMLBBH +#define MADMAC +#include "interfaces\mmIXML.h" +#import named_guids +using namespace MSXML2; + + + +#ifdef MADMAC +#include +//#include +#endif + +namespace mmXML +{ + //////////////////////////////////////////////////////////////////////////////// + /// Implementation of mmXMLNodeI interface based on Borland objects. + //////////////////////////////////////////////////////////////////////////////// + class mmXMLNodeBB: public mmXMLNodeI +#ifdef MADMAC + , mmLog::mmLogSender +#endif + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// Node name. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sNodeName; + //////////////////////////////////////////////////////////////////////////////// + /// Value of node. Used if vector of childs is empty. + //////////////////////////////////////////////////////////////////////////////// + mmString m_sNodeValue; + //////////////////////////////////////////////////////////////////////////////// + /// Vector with child nodes. + //////////////////////////////////////////////////////////////////////////////// + std::vector m_sChilds; + //////////////////////////////////////////////////////////////////////////////// + /// Vector with attributes of node. + //////////////////////////////////////////////////////////////////////////////// + std::vector m_sAttributes; + mmXML::mmXMLNodeI * m_psParent; + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + /// @param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// +#ifdef MADMAC + mmXMLNodeBB(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); +#else + mmXMLNodeBB(); +#endif + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmXMLNodeBB(); + + mmString GetName(void); + void SetName(mmString p_sName); + bool IsLeaf(void); + std::vector GetAttributes(void); + void AddAttribute(mmString p_sAttrName,mmString p_sAttrValue); +#ifdef MADMAC + void RemoveAttribute(mmString p_sAttrName); +#else + // bez wyjatkow, zwraca false jezeli wystapil blad + bool RemoveAttribute(mmString p_sAttrName); +#endif + void RemoveAllAttributes(void); + bool IsAttribute(mmString p_sAttrName); +#ifdef MADMAC + mmString GetAttributeValue(mmString p_sAttrName); +#else + // bez wyjatkow, zwraca pustego stringa w przypadku bledu + mmString GetAttributeValue(mmString p_sAttrName); +#endif + void SetAttributeValue(mmString p_sAttrName,mmString p_sAttrValue); + mmString GetText(void); + void SetText(mmString p_sText); + std::vector GetChilds(void); + mmXML::mmXMLNodeI* AddChild(mmString p_sChildName); + void AddChildWithStructure(mmXMLNodeI* p_psChildNode); + mmXML::mmXMLNodeI* FindChild(mmString p_sChildName); + mmXML::mmXMLNodeI* FindNextChild(mmXML::mmXMLNodeI* p_psCurrentChild, mmString p_sChildName); +#ifdef MADMAC + mmXML::mmXMLNodeI* GetChild(mmInt p_iChildIndex); + void RemoveChild(mmString p_sChildName); + void RemoveChild(mmInt p_iChildIndex); + +#else + // bez wyjatkow, zwraca NULL jezeli wystapil blad + mmXML::mmXMLNodeI* GetChild(mmInt p_iChildIndex); + // bez wyjatkow, zwraca false jezeli wystapil blad + bool RemoveChild(mmString p_sChildName); + // bez wyjatkow, zwraca false jezeli wystapil blad + bool RemoveChild(mmInt p_iChildIndex); +#endif + + void RemoveAllChilds(void); + mmXML::mmXMLNodeI* GetParent( void ); + mmXML::mmXMLNodeI* GetNextSibling( void ); + mmXML::mmXMLNodeI* GetPrevSibling( void ); + }; + + //////////////////////////////////////////////////////////////////////////////// + /// Implementation of mmXMLDocI interface. It uses Borland implementation. + //////////////////////////////////////////////////////////////////////////////// + class mmXMLDocBB: public mmXMLDocI +#ifdef MADMAC + ,mmLog::mmLogSender +#endif + { + private: // fields + //////////////////////////////////////////////////////////////////////////////// + /// XML document implemented by BB Team. + //////////////////////////////////////////////////////////////////////////////// + + //_di_IXMLDocument m_psXMLBBDoc; + MSXML2::IXMLDOMDocumentPtr m_psXMLBBDoc; + MSXML2::IXMLDOMElementPtr m_psDocRoot; + MSXML2::IXMLDOMNodePtr m_sCurrentNode; + //////////////////////////////////////////////////////////////////////////////// + /// Root node object. + //////////////////////////////////////////////////////////////////////////////// + mmXMLNodeBB m_sRootNode; + bool m_bOLEInitialized; + mmString m_sLastError; + + private: // methods + //////////////////////////////////////////////////////////////////////////////// + /// This method deletes XMLDocument and creates new one. Next, it fills + /// node structure into new XMLDocument. + //////////////////////////////////////////////////////////////////////////////// + void SaveNodeStructureIntoXMLDocument(void); + //////////////////////////////////////////////////////////////////////////////// + /// Method adds node with its children from XML structure into XMLDocument. + /// + /// @param[in] p_sBBNode XMLDocument node interface + /// @param[in] p_psMMNode XML structure element + //////////////////////////////////////////////////////////////////////////////// + //void FillXMLNodeIntoXMLDocument(_di_IXMLNode p_sBBNode,mmXMLNodeI* p_psMMNode); + void FillXMLNodeIntoXMLDocument(MSXML2::IXMLDOMNodePtr p_sBBNode,mmXMLNodeI* p_psMMNode); + //////////////////////////////////////////////////////////////////////////////// + /// Method returns formatted string representing XML structure. + /// + /// @return string with XML structure + //////////////////////////////////////////////////////////////////////////////// + mmString GetXMLFormattedString(void); + //////////////////////////////////////////////////////////////////////////////// + /// This method fills XML structure from XMLDocument. + //////////////////////////////////////////////////////////////////////////////// + void LoadNodeStructureFromXMLDocument(void); + //////////////////////////////////////////////////////////////////////////////// + /// Method fills node with its children from XMLDocument into XML structure. + /// + /// @param[in] p_sBBNode XMLDocument node interface + /// @param[in] p_psMMNode XML structure element + //////////////////////////////////////////////////////////////////////////////// +// void FillXMLNodeFromXMLDocument(_di_IXMLNode p_sBBNode,mmXMLNodeI* p_psMMNode); + void FillXMLNodeFromXMLDocument(MSXML2::IXMLDOMNodePtr p_sBBNode,mmXMLNodeI* p_psMMNode); + public: // methods + //////////////////////////////////////////////////////////////////////////////// + /// Constructor. + /// + /// @param[in] p_psLogReceiver pointer to log object. + //////////////////////////////////////////////////////////////////////////////// +#ifdef MADMAC + mmXMLDocBB(mmLog::mmLogReceiverI *p_psLogReceiver = NULL); +#else + mmXMLDocBB( ); +#endif + //////////////////////////////////////////////////////////////////////////////// + /// Destructor. + //////////////////////////////////////////////////////////////////////////////// + ~mmXMLDocBB(); + +#ifdef MADMAC + void ParseXMLFile(mmString p_sXMLFileName); + void ParseXMLBuffer(mmString p_sXMLBuffer); + void SaveToXMLFile(mmString p_sXMLFileName); + mmXMLNodeI* GetXMLRootNode(void); +#else + bool ParseXMLFile(mmString p_sXMLFileName); + bool ParseXMLBuffer(mmString p_sXMLBuffer); + bool SaveToXMLFile(mmString p_sXMLFileName); + mmXMLNodeI* GetXMLRootNode(void); + +#endif + + mmString SaveToXMLBuffer(void); + bool IsXMLStructureValid(void); + + void CreateXMLRootNode(mmString p_sRootNodeName); + void CopyXMLRootNodeStructure(mmXMLNodeI* p_psNode); + + + bool InitializeXML( void ); + void Load_XML_From_Buffer(mmString source); + bool Load_XML_Document(mmString strFileName); + void Reset_XML_Document(); + + + }; +}; + +#endif diff --git a/proj/libcalc2d/src/fileio/mmFileIOStd.cpp b/proj/libcalc2d/src/fileio/mmFileIOStd.cpp new file mode 100644 index 0000000..b402c52 --- /dev/null +++ b/proj/libcalc2d/src/fileio/mmFileIOStd.cpp @@ -0,0 +1,1630 @@ +#include + +#include + +#include +#include +#include + +#include +#include +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmFileIO - funkcje globalne +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmInt mmFileIO::GetFilePosition(std::ifstream* p_psFile) +{ + return p_psFile->tellg(); +} + +mmInt mmFileIO::GetFilePosition(std::wifstream* p_psFile) +{ + return p_psFile->tellg(); +} + +mmInt mmFileIO::GetFilePosition(std::ofstream* p_psFile) +{ + return p_psFile->tellp(); +} + +mmInt mmFileIO::GetFilePosition(std::wofstream* p_psFile) +{ + return p_psFile->tellp(); +} + +void mmFileIO::SetFilePosition(std::ifstream* p_psFile,mmInt p_iFilePos) +{ + p_psFile->seekg(p_iFilePos,std::ios_base::beg); +} + +void mmFileIO::SetFilePosition(std::wifstream* p_psFile,mmInt p_iFilePos) +{ + p_psFile->seekg(p_iFilePos,std::ios_base::beg); +} + +void mmFileIO::SetFilePosition(std::ofstream* p_psFile,mmInt p_iFilePos) +{ + p_psFile->seekp(p_iFilePos,std::ios_base::beg); +} + +void mmFileIO::SetFilePosition(std::wofstream* p_psFile,mmInt p_iFilePos) +{ + p_psFile->seekp(p_iFilePos,std::ios_base::beg); +} + +mmInt mmFileIO::GetFileLenght(std::ifstream* p_psFile) +{ + // zapisuję aktualną pozycję + mmInt v_iActFilePos = GetFilePosition(p_psFile); + + // idę na koniec pliku + p_psFile->seekg(0,std::ios_base::end); + // pobieram pozycję końca pliku + mmInt v_iFileLenght = GetFilePosition(p_psFile); + + // wracam na położenie początkowe + p_psFile->seekg(v_iActFilePos,std::ios_base::beg); + + // zwaracam pozycję końca pliku + return v_iFileLenght; +} + +mmInt mmFileIO::GetFileLenght(std::wifstream* p_psFile) +{ + // zapisuję aktualną pozycję + mmInt v_iActFilePos = GetFilePosition(p_psFile); + + // idę na koniec pliku + p_psFile->seekg(0,std::ios_base::end); + // pobieram pozycję końca pliku + mmInt v_iFileLenght = GetFilePosition(p_psFile); + + // wracam na położenie początkowe + p_psFile->seekg(v_iActFilePos,std::ios_base::beg); + + // zwaracam pozycję końca pliku + return v_iFileLenght; +} + +mmInt mmFileIO::GetFileLenght(std::ofstream* p_psFile) +{ + // zapisuję aktualną pozycję + mmInt v_iActFilePos = GetFilePosition(p_psFile); + + // idę na koniec pliku + p_psFile->seekp(0,std::ios_base::end); + // pobieram pozycję końca pliku + mmInt v_iFileLenght = GetFilePosition(p_psFile); + + // wracam na położenie początkowe + p_psFile->seekp(v_iActFilePos,std::ios_base::beg); + + // zwaracam pozycję końca pliku + return v_iFileLenght; +} + +mmInt mmFileIO::GetFileLenght(std::wofstream* p_psFile) +{ + // zapisuję aktualną pozycję + mmInt v_iActFilePos = GetFilePosition(p_psFile); + + // idę na koniec pliku + p_psFile->seekp(0,std::ios_base::end); + // pobieram pozycję końca pliku + mmInt v_iFileLenght = GetFilePosition(p_psFile); + + // wracam na położenie początkowe + p_psFile->seekp(v_iActFilePos,std::ios_base::beg); + + // zwaracam pozycję końca pliku + return v_iFileLenght; +} + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmFileIO::mmFileUtilsSTD +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmFileIO::mmFileUtilsSTD::mmFileUtilsSTD(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmFileIO::mmFileUtilsSTD",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmFileIO::mmFileUtilsSTD::~mmFileUtilsSTD() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +void mmFileIO::mmFileUtilsSTD::CreateDir(mmString p_sDirName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start CreateDir Name=")+ + p_sDirName); + + try + { + mmOperatingSystem::CreateDir(p_sDirName); + } + catch(mmError &v_sErr) + { + switch(v_sErr.GetErrorCode()) + { + case mmeFileIOPermissionToFileDenied: + { + SendLogMessage(mmLog::critical,mmString(L"CreateDir PermissionDenied")); + }; + break; + case mmeFileIONoSuchFileOrDirectory: + { + SendLogMessage(mmLog::critical,mmString(L"CreateDir NoSuchFileOrDirectory")); + }; + break; + case mmeFileIOUnknownError: + { + SendLogMessage(mmLog::critical,mmString(L"CreateDir UnknownError")); + }; + break; + }; + + throw v_sErr; + }; + + SendLogMessage(mmLog::debug,mmString(L"End CreateDir")); +} + +void mmFileIO::mmFileUtilsSTD::CreateDirStructure(mmString p_sDirName) +{ + std::stack v_sDirStack; + mmString v_sActDir = p_sDirName; + + SendLogMessage(mmLog::debug,mmString(L"Start CreateDirStructure Name=")+ + p_sDirName); + + // tworzę stos katalogów do utworzenia + while(!IsExistingDir(v_sActDir)) + { + v_sDirStack.push(v_sActDir); + + v_sActDir.resize(v_sActDir.find_last_of(L"\\")); + }; + + // tworzę katalogi ze stosu + while(!v_sDirStack.empty()) + { + CreateDir(v_sDirStack.top()); + + v_sDirStack.pop(); + }; + + SendLogMessage(mmLog::debug,mmString(L"End CreateDirStructure")); +} + +void mmFileIO::mmFileUtilsSTD::ClearDir(mmString p_sDirName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ClearDir Name=")+ + p_sDirName); + + // pobieram informację o zawartości wybranego katalogu + std::vector v_sDirectoryElements = GetDirElements(p_sDirName,L"*.*"); + + // usuwam wszystkie elementy wektora v_sDirectoryElements + for(mmInt v_i=0;v_i(v_sDirectoryElements.size());v_i++) + { + if(v_sDirectoryElements[v_i].bFile) + { + SendLogMessage(mmLog::debug,mmString(L"ClearDir RemovingFile=") + + v_sDirectoryElements[v_i].sName); + + RemoveFile(p_sDirName + + mmString(L"\\") + + v_sDirectoryElements[v_i].sName); + } + else + { + SendLogMessage(mmLog::debug,mmString(L"ClearDir RemovingDir=") + + v_sDirectoryElements[v_i].sName); + + RemoveDir(p_sDirName + + mmString(L"\\") + + v_sDirectoryElements[v_i].sName, + true); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ClearDir")); +} + +void mmFileIO::mmFileUtilsSTD::RemoveDir(mmString p_sDirName, + bool p_bWithElements) +{ + SendLogMessage(mmLog::debug,mmString(L"Start RemoveDir Name=")+ + p_sDirName); + + if(p_bWithElements) + { + ClearDir(p_sDirName); + }; + + try + { + mmOperatingSystem::RemoveDir(p_sDirName); + } + catch(mmError &v_sErr) + { + switch(v_sErr.GetErrorCode()) + { + case mmeFileIOPermissionToFileDenied: + { + SendLogMessage(mmLog::critical,mmString(L"RemoveDir PermissionDenied")); + }; + break; + case mmeFileIONoSuchFileOrDirectory: + { + SendLogMessage(mmLog::critical,mmString(L"RemoveDir NoSuchFileOrDirectory")); + }; + break; + case mmeFileIOUnknownError: + { + SendLogMessage(mmLog::critical,mmString(L"RemoveDir UnknownError")); + }; + break; + }; + + throw v_sErr; + }; + + SendLogMessage(mmLog::debug,mmString(L"End RemoveDir")); +} + +bool mmFileIO::mmFileUtilsSTD::IsExistingDir(mmString p_sDirName) +{ + bool v_bExist; + + SendLogMessage(mmLog::debug,mmString(L"Start IsExistingDir Name=")+ + p_sDirName); + + try + { + v_bExist = mmOperatingSystem::IsExistingDir(p_sDirName); + } + catch(mmError &v_sErr) + { + switch(v_sErr.GetErrorCode()) + { + case mmeFileIOUnknownError: + { + SendLogMessage(mmLog::critical,mmString(L"IsExistingDir UnknownError")); + }; + break; + }; + + throw v_sErr; + }; + + SendLogMessage(mmLog::debug,mmString(L"End IsExistingDir Res=") + + mmStringUtilities::BoolToString(v_bExist)); + + return v_bExist; +} + +mmString mmFileIO::mmFileUtilsSTD::GetTemporaryDir(void) +{ + wchar_t* v_pcTemp; + + SendLogMessage(mmLog::debug,mmString(L"Start GetTemporaryDir")); + + v_pcTemp = _wgetenv(L"TEMP"); + if(v_pcTemp == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetTemporaryDir No_TEMP_EnvironmentVariable")); + + throw mmError(mmeFileIONoTemporaryDirectory); + }; + + mmString v_sTempDir = v_pcTemp; + + SendLogMessage(mmLog::debug,mmString(L"End GetTemporaryDir Dir=")+ + v_sTempDir); + + return v_sTempDir; +} + +mmString mmFileIO::mmFileUtilsSTD::GetApplicationDir(void) +{ + mmString v_sAppDir; + + SendLogMessage(mmLog::debug,mmString(L"Start GetApplicationDir")); + + v_sAppDir = mmOperatingSystem::GetApplicationDirectory(); + + SendLogMessage(mmLog::debug,mmString(L"End GetApplicationDir")); + + return v_sAppDir; +} + +std::vector mmFileIO::mmFileUtilsSTD::GetDirElements(mmString p_sDirName, + mmString p_sDirWildcards) +{ + std::vector v_sDirElements; + + SendLogMessage(mmLog::debug,mmString(L"Start GetDirElements Name=")+ + p_sDirName); + + try + { + v_sDirElements = mmOperatingSystem::GetDirectoryElements(p_sDirName,p_sDirWildcards); + } + catch(mmError &v_sErr) + { + switch(v_sErr.GetErrorCode()) + { + case mmeFileIONoSuchFileOrDirectory: + { + SendLogMessage(mmLog::critical,mmString(L"GetDirElements NoSuchFileOrDirectory")); + }; + break; + case mmeFileIOUnknownError: + { + SendLogMessage(mmLog::critical,mmString(L"GetDirElements UnknownError")); + }; + break; + }; + + throw v_sErr; + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetDirElements")); + + return v_sDirElements; +} + +bool mmFileIO::mmFileUtilsSTD::IsEmptyDir(mmString p_sDirName) +{ + bool v_bIsEmpty = false; + + SendLogMessage(mmLog::debug,mmString(L"Start IsEmptyDir Name=")+ + p_sDirName); + + std::vector v_sDirElements = GetDirElements(p_sDirName,L"*.*"); + if(v_sDirElements.size() == 0) + { + v_bIsEmpty = true; + }; + + SendLogMessage(mmLog::debug,mmString(L"End IsEmptyDir Res=") + + mmStringUtilities::BoolToString(v_bIsEmpty)); + + return v_bIsEmpty; +} + +void mmFileIO::mmFileUtilsSTD::RemoveFile(mmString p_sFileName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start RemoveFile Name=")+ + p_sFileName); + + int v_iRes = _wremove(p_sFileName.c_str()); + if(v_iRes != 0) + { + switch(errno) + { + case EACCES: + { + SendLogMessage(mmLog::critical,mmString(L"RemoveFile PermissionDenied")); + + throw mmError(mmeFileIOPermissionToFileDenied); + }; + case ENOENT: + { + SendLogMessage(mmLog::critical,mmString(L"RemoveFile NoSuchFileOrDirectory")); + + throw mmError(mmeFileIONoSuchFileOrDirectory); + }; + default: + { + SendLogMessage(mmLog::critical,mmString(L"RemoveFile UnknownError")); + + throw mmError(mmeFileIOUnknownError); + }; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End RemoveFile")); +} + +bool mmFileIO::mmFileUtilsSTD::IsExistingFile(mmString p_sFileName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start IsExistingFile Name=")+ + p_sFileName); + + bool v_bIsExisting = mmOperatingSystem::IsExistingFile(p_sFileName); + + SendLogMessage(mmLog::debug,mmString(L"End IsExistingFile Res=") + + mmStringUtilities::BoolToString(v_bIsExisting)); + + return v_bIsExisting; +} + +mmString mmFileIO::mmFileUtilsSTD::GetPathToFile(mmString p_sFileName) +{ + mmString v_sPath; + + SendLogMessage(mmLog::debug,mmString(L"Start GetPathToFile Name=")+ + p_sFileName); + + v_sPath = p_sFileName.substr(0,p_sFileName.find_last_of(L"\\")); + + SendLogMessage(mmLog::debug,mmString(L"End GetPathToFile Path=")+ + v_sPath); + + return v_sPath; +} + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmFileIO::mmTextFileReadSTD +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmFileIO::mmTextFileReadSTD::mmTextFileReadSTD(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmFileIO::mmTextFileReadSTD",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + // inicjalizuję pustym plikiem i niewykorzystaną pamięcią + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmFileIO::mmTextFileReadSTD::~mmTextFileReadSTD() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + this->Close(); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +void mmFileIO::mmTextFileReadSTD::Open(mmString p_sFileName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Open FileName=") + + p_sFileName); + + // jeśli poprzednio był otwarty to zamykam + this->Close(); + + // ustalam stan obiektu + m_sFileName = p_sFileName; + + // otwieram plik + try + { + m_psFile = new std::wifstream(p_sFileName.c_str()); + } + catch(std::bad_alloc) + { + SendLogMessage(mmLog::critical,mmString(L"Open ErrorAllocationMemory")); + + throw mmError(mmeBadAlloc); + }; + + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Open BadOpen")); + + throw mmError(mmeFileIOCantOpenFile); + }; + + SendLogMessage(mmLog::debug,mmString(L"End Open")); +} + +void mmFileIO::mmTextFileReadSTD::Close(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Close")); + + delete m_psFile; + + // inicjalizuję pustym plikiem + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Close")); +} + +bool mmFileIO::mmTextFileReadSTD::ReadChar(wchar_t* p_pcChar) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ReadChar")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"ReadChar NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"ReadChar FileError")); + + throw mmError(mmeFileIOCantReadFromFile); + } + else + { + // czytam znak + m_psFile->get(*p_pcChar); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::debug,mmString(L"End ReadChar Failed")); + + return false; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ReadChar Success")); + + return true; +} + +bool mmFileIO::mmTextFileReadSTD::ReadLine(mmString* p_psFileLine) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ReadLine")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"ReadLine NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"ReadLine FileError")); + + throw mmError(mmeFileIOCantReadFromFile); + } + else + { + wchar_t v_tcTempBuf[2048]; + + // czytam linię + m_psFile->getline(v_tcTempBuf,2048); + *p_psFileLine = v_tcTempBuf; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::debug,mmString(L"End ReadLine Failed")); + + return false; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ReadLine Success")); + + return true; +} + +mmInt mmFileIO::mmTextFileReadSTD::ReadLines(std::vector* p_psLines, + mmInt p_iLinesCount) +{ + mmString v_sTempString; + mmInt v_iLinesRead = 0; + + SendLogMessage(mmLog::debug,mmString(L"Start ReadLines No=") + + mmStringUtilities::MMIntToString(p_iLinesCount)); + + while(v_iLinesRead < p_iLinesCount) + { + if(this->ReadLine(&v_sTempString)) + { + v_iLinesRead++; + p_psLines->push_back(v_sTempString); + } + else + { + break; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ReadLines No=") + + mmStringUtilities::MMIntToString(v_iLinesRead)); + + return v_iLinesRead; +} + +mmInt mmFileIO::mmTextFileReadSTD::GetLenght(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetLenght")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetLenght NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + mmInt v_iFileLenght = GetFileLenght(m_psFile); + + SendLogMessage(mmLog::debug,mmString(L"End GetLenght")); + + return v_iFileLenght; +} + +mmInt mmFileIO::mmTextFileReadSTD::ReadWholeFile(wchar_t* p_pcFileContent) +{ + mmInt v_iReadCount; + + SendLogMessage(mmLog::debug,mmString(L"Start ReadWholeFile")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"ReadWholeFile NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"ReadWholeFile FileErrorBefore")); + + // błąd - plik w stanie niewłaściwym + throw mmError(mmeFileIOCantReadFromFile); + } + else + { + // przechodzę na początek pliku + m_psFile->seekg(0); + + // czytam plik do bufora + //v_iReadCount = m_psFile->readsome(p_pcFileContent,GetFileLenght(m_psFile)); + v_iReadCount = GetFileLenght(m_psFile); + m_psFile->read(p_pcFileContent,v_iReadCount); + + // sprawdzam stan pliku po odczycie + if( ( (!(*m_psFile)) && (v_iReadCount == 0) ) || (m_psFile->bad()) ) + { + SendLogMessage(mmLog::critical,mmString(L"ReadWholeFile FileError")); + + throw mmError(mmeFileIOCantReadFromFile); + } + else + { + // usuwam failbit ze stanu strumienia + if(m_psFile->fail()) + { + m_psFile->setstate(m_psFile->rdstate()-std::ios_base::failbit); + }; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ReadWholeFile CharsReaded=") + + mmStringUtilities::MMIntToString(v_iReadCount)); + + return v_iReadCount; +} + +bool mmFileIO::mmTextFileReadSTD::Eof(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Eof")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"Eof NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + bool v_bIsEof = m_psFile->eof(); + + SendLogMessage(mmLog::debug,mmString(L"End Eof Res=")+ + mmStringUtilities::BoolToString(v_bIsEof)); + + return v_bIsEof; +} + +bool mmFileIO::mmTextFileReadSTD::IsActiveFile(void) +{ + bool v_bIsActive = true; + + SendLogMessage(mmLog::debug,mmString(L"IsActiveFile")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + v_bIsActive = false; + }; + + SendLogMessage(mmLog::debug,mmString(L"End IsActiveFile Res=")+ + mmStringUtilities::BoolToString(v_bIsActive)); + + return v_bIsActive; +} + +mmInt mmFileIO::mmTextFileReadSTD::GetActualFilePosition(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetActualFilePosition")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetActualFilePosition NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + mmInt v_iActFilePos = GetFilePosition(m_psFile); + + SendLogMessage(mmLog::debug,mmString(L"End GetActualFilePosition")); + + return v_iActFilePos; +} + +mmString mmFileIO::mmTextFileReadSTD::GetFileName(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetFileName")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetFileName NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetFileName")); + + return m_sFileName; +} + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmFileIO::mmTextFileWriteSTD +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmFileIO::mmTextFileWriteSTD::mmTextFileWriteSTD(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmFileIO::mmTextFileWriteSTD",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmFileIO::mmTextFileWriteSTD::~mmTextFileWriteSTD() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + this->Close(); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +void mmFileIO::mmTextFileWriteSTD::Open(mmString p_sFileName, + eOpenFileMode p_eOpenMode) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Open FileName=") + + p_sFileName); + + // jeśli poprzednio był otwarty to zamykam + this->Close(); + + // ustalam stan obiektu + m_sFileName = p_sFileName; + + std::string v_sFileName = mmStringUtilities::MMStringToCharString(m_sFileName); + + // otwieram plik + try + { + // jeśli zapisywanie od końca pliku + if(p_eOpenMode == append_for_write) + { + m_psFile = new std::wofstream(v_sFileName.c_str(),std::ios_base::app); + + SendLogMessage(mmLog::debug,mmString(L"Open MoveToEof")); + } + else + { + m_psFile = new std::wofstream(v_sFileName.c_str()); + }; + } + catch(std::bad_alloc) + { + SendLogMessage(mmLog::critical,mmString(L"Open ErrorAllocationMemory")); + + throw mmError(mmeBadAlloc); + }; + + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Open BadOpen")); + + throw mmError(mmeFileIOCantOpenFile); + }; + + SendLogMessage(mmLog::debug,mmString(L"End Open")); +} + +void mmFileIO::mmTextFileWriteSTD::Close(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Close")); + + try + { + if(m_psFile != NULL) + { + Flush(); + + m_psFile->close(); + }; + } + catch(mmError &v_sErr) + { + // zamykam plik + delete m_psFile; + + throw v_sErr; + }; + + // zamykam plik + delete m_psFile; + + // inicjalizuję stan zmiennych + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Close")); +} + +void mmFileIO::mmTextFileWriteSTD::WriteChar(wchar_t p_cChar) +{ + SendLogMessage(mmLog::debug,mmString(L"Start WriteChar")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"WriteChar NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteChar FileError")); + + throw mmError(mmeFileIOCantWriteToFile); + } + else + { + // zapisuję znak + m_psFile->write(&p_cChar,1); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteChar Failed")); + + throw mmError(mmeFileIOCantWriteToFile); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End WriteChar")); +} + +void mmFileIO::mmTextFileWriteSTD::WriteLine(mmString p_sFileLine) +{ + SendLogMessage(mmLog::debug,mmString(L"Start WriteLine")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"WriteLine NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteLine FileError")); + + // błąd - plik w stanie niewłaściwym + throw mmError(mmeFileIOCantWriteToFile); + } + else + { + // zapisuję linię + (*m_psFile) << p_sFileLine; + (*m_psFile) << std::endl; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteLine Failed")); + + throw mmError(mmeFileIOCantWriteToFile); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End WriteLine")); +} + +void mmFileIO::mmTextFileWriteSTD::WriteLines(std::vector* p_psLines) +{ + SendLogMessage(mmLog::debug,mmString(L"Start WriteLines")); + + // sprawdzam czy wskaźnik pusty + if(p_psLines == NULL) + { + SendLogMessage(mmLog::debug,mmString(L"WriteLines NoLinesToSave")); + + return; + }; + + mmInt v_iLinesToWrite = static_cast(p_psLines->size()); + mmInt v_i; + + for(v_i=0;v_iWriteLine((*p_psLines)[v_i]); + }; + + SendLogMessage(mmLog::debug,mmString(L"End WriteLinesSuccess No=") + + mmStringUtilities::MMIntToString(v_iLinesToWrite)); +} + +void mmFileIO::mmTextFileWriteSTD::WriteBuffer(wchar_t const* p_pcBuffer,mmInt p_iBufferSize) +{ + SendLogMessage(mmLog::debug,mmString(L"Start WriteBuffer")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"WriteBuffer NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteBuffer FileErrorBefore")); + + throw mmError(mmeFileIOCantWriteToFile); + } + else + { + // zapisuję bufor do pliku + m_psFile->write(p_pcBuffer,p_iBufferSize); + + // sprawdzam stan pliku po zapisie + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteBuffer FileError")); + + throw mmError(mmeFileIOCantWriteToFile); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End WriteBuffer")); +} + +void mmFileIO::mmTextFileWriteSTD::WriteEol(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start WriteEol")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"WriteEol NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteEol FileError")); + + throw mmError(mmeFileIOCantWriteToFile); + } + else + { + // zapisuję koniec linii + (*m_psFile) << std::endl; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteEol Failed")); + + throw mmError(mmeFileIOCantWriteToFile); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End WriteEol")); +} + +void mmFileIO::mmTextFileWriteSTD::Flush(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Flush")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"Flush NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Flush FileError")); + + throw mmError(mmeFileIOCantWriteToFile); + } + else + { + // zapisuję na dysk bufory + m_psFile->flush(); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Flush Failed")); + + throw mmError(mmeFileIOCantWriteToFile); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End Flush")); +} + +bool mmFileIO::mmTextFileWriteSTD::IsActiveFile(void) +{ + bool v_bIsActive = true; + + SendLogMessage(mmLog::debug,mmString(L"Start IsActiveFile")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + v_bIsActive = false; + }; + + SendLogMessage(mmLog::debug,mmString(L"End IsActiveFile Res=")+ + mmStringUtilities::BoolToString(v_bIsActive)); + + return v_bIsActive; +} + +mmString mmFileIO::mmTextFileWriteSTD::GetFileName(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetFileName")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetFileName NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetFileName")); + + return m_sFileName; +} + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmFileIO::mmBinaryFileReadSTD +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmFileIO::mmBinaryFileReadSTD::mmBinaryFileReadSTD(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmFileIO::mmBinaryFileReadSTD",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + // inicjalizuję pustym plikiem i niewykorzystaną pamięcią + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmFileIO::mmBinaryFileReadSTD::~mmBinaryFileReadSTD() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + this->Close(); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +void mmFileIO::mmBinaryFileReadSTD::Open(mmString p_sFileName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Open FileName=") + + p_sFileName); + + // jeśli poprzednio był otwarty to zamykam + this->Close(); + + // ustalam stan obiektu + m_sFileName = p_sFileName; + + // otwieram plik + try + { + m_psFile = new std::ifstream(mmStringUtilities::MMStringToCharString(p_sFileName).c_str(),std::ios_base::binary); + } + catch(std::bad_alloc) + { + SendLogMessage(mmLog::critical,mmString(L"Open ErrorAllocationMemory")); + + throw mmError(mmeBadAlloc); + }; + + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Open BadOpen")); + + throw mmError(mmeFileIOCantOpenFile); + }; + + SendLogMessage(mmLog::debug,mmString(L"End Open")); +} + +void mmFileIO::mmBinaryFileReadSTD::Close(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Close")); + + delete m_psFile; + + // inicjalizuję pustym plikiem + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Close")); +} + +bool mmFileIO::mmBinaryFileReadSTD::ReadBuffer(void* p_pBuffer,mmInt p_iSize) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ReadBuffer")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"ReadBuffer NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"ReadBuffer FileError")); + + throw mmError(mmeFileIOCantReadFromFile); + } + else + { + // czytam bufor + m_psFile->read(reinterpret_cast(p_pBuffer),p_iSize); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::debug,mmString(L"End ReadBuffer Failed")); + + return false; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ReadBuffer Success")); + + return true; +} + +mmInt mmFileIO::mmBinaryFileReadSTD::GetLenght(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetLenght")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetLenght NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + mmInt v_iFileLenght = GetFileLenght(m_psFile); + + SendLogMessage(mmLog::debug,mmString(L"End GetLenght")); + + return v_iFileLenght; +} + +bool mmFileIO::mmBinaryFileReadSTD::Eof(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Eof")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"Eof NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + bool v_bIsEof = m_psFile->eof(); + + SendLogMessage(mmLog::debug,mmString(L"End Eof Res=")+ + mmStringUtilities::BoolToString(v_bIsEof)); + + return v_bIsEof; +} + +bool mmFileIO::mmBinaryFileReadSTD::IsActiveFile(void) +{ + bool v_bIsActive = true; + + SendLogMessage(mmLog::debug,mmString(L"IsActiveFile")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + v_bIsActive = false; + }; + + SendLogMessage(mmLog::debug,mmString(L"End IsActiveFile Res=")+ + mmStringUtilities::BoolToString(v_bIsActive)); + + return v_bIsActive; +} + +mmInt mmFileIO::mmBinaryFileReadSTD::GetActualFilePosition(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetActualFilePosition")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetActualFilePosition NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + mmInt v_iActFilePos = GetFilePosition(m_psFile); + + SendLogMessage(mmLog::debug,mmString(L"End GetActualFilePosition")); + + return v_iActFilePos; +} + +void mmFileIO::mmBinaryFileReadSTD::SetActualFilePosition(mmInt p_iFilePos) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetActualFilePosition")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"SetActualFilePosition NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + SetFilePosition(m_psFile,p_iFilePos); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"SetActualFilePosition NoSuchPosition")); + + throw mmError(mmeFileIOBadFilePosition); + }; + + SendLogMessage(mmLog::debug,mmString(L"End SetActualFilePosition")); +} + +mmString mmFileIO::mmBinaryFileReadSTD::GetFileName(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetFileName")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetFileName NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetFileName")); + + return m_sFileName; +} + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmFileIO::mmBinaryFileWriteSTD +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmFileIO::mmBinaryFileWriteSTD::mmBinaryFileWriteSTD(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmFileIO::mmBinaryFileWriteSTD",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmFileIO::mmBinaryFileWriteSTD::~mmBinaryFileWriteSTD() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + this->Close(); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +void mmFileIO::mmBinaryFileWriteSTD::Open(mmString p_sFileName, + mmFileIO::eOpenFileMode p_eOpenMode) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Open FileName=") + + p_sFileName); + + // jeśli poprzednio był otwarty to zamykam + this->Close(); + + // ustalam stan obiektu + m_sFileName = p_sFileName; + + // otwieram plik + try + { + // jeśli zapisywanie od końca pliku + if(p_eOpenMode == append_for_write) + { + m_psFile = new std::ofstream(p_sFileName.c_str(),std::ios_base::app|std::ios_base::binary); + + SendLogMessage(mmLog::debug,mmString(L"Open MoveToEof")); + } + else + { + m_psFile = new std::ofstream(p_sFileName.c_str(),std::ios_base::trunc|std::ios_base::binary); + }; + } + catch(std::bad_alloc) + { + SendLogMessage(mmLog::critical,mmString(L"Open ErrorAllocationMemory")); + + throw mmError(mmeBadAlloc); + }; + + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Open BadOpen")); + + throw mmError(mmeFileIOCantOpenFile); + }; + + SendLogMessage(mmLog::debug,mmString(L"End Open")); +} + +void mmFileIO::mmBinaryFileWriteSTD::Close(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Close")); + + try + { + if(m_psFile != NULL) + { + Flush(); + }; + } + catch(mmError &v_sErr) + { + // zamykam plik + delete m_psFile; + + throw v_sErr; + }; + + // zamykam plik + delete m_psFile; + + // inicjalizuję stan zmiennych + m_psFile = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Close")); +} + +bool mmFileIO::mmBinaryFileWriteSTD::WriteBuffer(void* p_pBuffer,mmInt p_iSize) +{ + SendLogMessage(mmLog::debug,mmString(L"Start WriteBuffer")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"WriteBuffer NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"WriteBuffer FileError")); + + throw mmError(mmeFileIOCantReadFromFile); + } + else + { + // zapisuję bufor + m_psFile->write(reinterpret_cast(p_pBuffer),p_iSize); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::debug,mmString(L"End WriteBuffer Failed")); + + return false; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End WriteBuffer Success")); + + return true; +} + +mmInt mmFileIO::mmBinaryFileWriteSTD::GetLenght(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetLenght")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetLenght NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + mmInt v_iFileLenght = GetFileLenght(m_psFile); + + SendLogMessage(mmLog::debug,mmString(L"End GetLenght")); + + return v_iFileLenght; +} + +bool mmFileIO::mmBinaryFileWriteSTD::IsActiveFile(void) +{ + bool v_bIsActive = true; + + SendLogMessage(mmLog::debug,mmString(L"IsActiveFile")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + v_bIsActive = false; + }; + + SendLogMessage(mmLog::debug,mmString(L"End IsActiveFile Res=")+ + mmStringUtilities::BoolToString(v_bIsActive)); + + return v_bIsActive; +} + +mmInt mmFileIO::mmBinaryFileWriteSTD::GetActualFilePosition(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetActualFilePosition")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetActualFilePosition NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + mmInt v_iActFilePos = GetFilePosition(m_psFile); + + SendLogMessage(mmLog::debug,mmString(L"End GetActualFilePosition")); + + return v_iActFilePos; +} + +void mmFileIO::mmBinaryFileWriteSTD::SetActualFilePosition(mmInt p_iFilePos) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetActualFilePosition")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"SetActualFilePosition NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + SetFilePosition(m_psFile,p_iFilePos); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"SetActualFilePosition NoSuchPosition")); + + throw mmError(mmeFileIOBadFilePosition); + }; + + SendLogMessage(mmLog::debug,mmString(L"End SetActualFilePosition")); +} + +mmString mmFileIO::mmBinaryFileWriteSTD::GetFileName(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetFileName")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"GetFileName NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetFileName")); + + return m_sFileName; +} + +void mmFileIO::mmBinaryFileWriteSTD::Flush(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Flush")); + + // sprawdzam czy plik jest zainicjowany + if(m_psFile == NULL) + { + SendLogMessage(mmLog::critical,mmString(L"Flush NoFileOpened")); + + throw mmError(mmeFileIOFileIsNotOpened); + }; + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Flush FileError")); + + throw mmError(mmeFileIOCantWriteToFile); + } + else + { + // zapisuję na dysk bufory + m_psFile->flush(); + + // sprawdzam stan pliku + if(!(*m_psFile)) + { + SendLogMessage(mmLog::critical,mmString(L"Flush Failed")); + + throw mmError(mmeFileIOCantWriteToFile); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End Flush")); +} + + diff --git a/proj/libcalc2d/src/images/mmCalcMethod.cpp b/proj/libcalc2d/src/images/mmCalcMethod.cpp new file mode 100644 index 0000000..6131e7c --- /dev/null +++ b/proj/libcalc2d/src/images/mmCalcMethod.cpp @@ -0,0 +1,318 @@ + +#pragma once + +#include +#include +#include +#include +#include + +mmImages::mmCalcMethod::mmCalcMethod(mmLog::mmLogReceiverI *p_psLogReceiver, + mmString p_sClassName): + mmLog::mmLogSender(p_sClassName,p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + swprintf(m_sCMParams.sShortName, L"Generic calculation method"); + swprintf(m_sCMParams.sIDName, L"{C13390E5-EBA6-404d-8706-B07FFE01C52F}"); + swprintf(m_sCMParams.sDescription,L"Generic calculation method"); + m_sCMParams.bIsMultithreaded = true; + + m_psThreadSynchEL.reset(mmInterfaceInitializers::CreateExclusiveLock(NULL)); + + m_rProgress = 0.0; + m_bIsExecuting = false; + m_bStopExecution = false; + + m_psImageStructure = NULL; + + m_iRowsCountInBlock = 100; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} +//--------------------------------------------------------------------------- +mmImages::mmCalcMethod::~mmCalcMethod() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} +//--------------------------------------------------------------------------- +mmImages::mmImagesCalculationMethodI::sCalculationMethodParams mmImages::mmCalcMethod::GetCalculationMethodInfo(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetCalculationMethodInfo")); + + SendLogMessage(mmLog::debug,mmString(L"End GetCalculationMethodInfo")); + + return m_sCMParams; +} +//--------------------------------------------------------------------------- +void mmImages::mmCalcMethod::SetCalculationMethodParameters(mmImages::mmImageStructureI* p_psImageStructure, + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetCalculationMethodParameters")); + + m_psImageStructure = p_psImageStructure; + + if (p_psAutomationParams != NULL) { + std::auto_ptr v_psXMLDoc(mmInterfaceInitializers::CreateXMLDocument()); + v_psXMLDoc->ParseXMLBuffer(p_psAutomationParams->sInParams); + for (mmUInt i = 0; i < m_vParameters.size(); ++i) { + mmXML::GetValue(v_psXMLDoc.get(), m_vParameters[i].m_sPosition, m_vParameters[i].m_pValue.get()); + } + } + + RetrieveParameters(); + m_rProgress = 0.0; + m_iThreadsCount = 0; + m_bFinishImage = false; + + // prepare map with first available row for each image + m_mNextRows.clear(); + std::vector v_sImageNames = GetImageNames(); + for (mmUInt i = 0; i < v_sImageNames.size(); ++i) { + m_mNextRows[v_sImageNames[i]] = 0; + } + + SendLogMessage(mmLog::debug,mmString(L"End SetCalculationMethodParameters")); +} +//--------------------------------------------------------------------------- +void mmImages::mmCalcMethod::UserAction(mmString p_sXMLParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UserAction")); + + SendLogMessage(mmLog::debug,mmString(L"End UserAction")); +} +//--------------------------------------------------------------------------- +void mmImages::mmCalcMethod::UserAction(wchar_t* p_pcXMLParamsBuffer, mmInt p_iXMLParamsBufferSize) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UserAction")); + + UserAction(p_pcXMLParamsBuffer); + + SendLogMessage(mmLog::debug,mmString(L"End UserAction")); +} +//--------------------------------------------------------------------------- +bool mmImages::mmCalcMethod::Execute(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Execute")); + + bool v_bResult = Calculate(); + + SendLogMessage(mmLog::debug,mmString(L"End Execute")); + + return v_bResult; +} +//--------------------------------------------------------------------------- +void mmImages::mmCalcMethod::StopExecution(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start StopExecution")); + + m_bStopExecution = true; + + SendLogMessage(mmLog::debug,mmString(L"End StopExecution")); +} +//--------------------------------------------------------------------------- +bool mmImages::mmCalcMethod::IsExecuting(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start IsExecuting")); + + SendLogMessage(mmLog::debug,mmString(L"End IsExecuting")); + + return m_bIsExecuting; +} +//--------------------------------------------------------------------------- +mmReal mmImages::mmCalcMethod::GetProgress(void) +{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetProgress")); + +// SendLogMessage(mmLog::debug,mmString(L"End GetProgress")); + + return m_rProgress; +} +//--------------------------------------------------------------------------- +void mmImages::mmCalcMethod::ForEachImage(mmCalcKernelI* p_psKernel) +{ + mmImageI* v_psLocalCurrentImage = NULL; + //mmInt v_iLocalCurrentImage = 0; + mmInt v_iBlockHeight = 0; + mmInt v_iNextRowIndex = 0; + mmInt v_iWidth = 0; + mmInt v_iHeight = 0; + mmInt v_iChannels = 0; + std::vector v_sImageNames = GetImageNames(); + bool v_bNewImage = false; + bool v_bFinishImage = false; + + m_psThreadSynchEL->Lock(); + m_iThreadsCount++; + v_iBlockHeight = m_iRowsCountInBlock; + m_psThreadSynchEL->Unlock(); + + for (mmUInt v_iIndex = 0; v_iIndex < m_psImageStructure->GetImageCount(); ++v_iIndex) { + + //m_psImageStructure->LockForRead(); + v_psLocalCurrentImage = m_psImageStructure->GetImage(v_iIndex); + //m_psImageStructure->UnlockFromRead(); + + m_psThreadSynchEL->Lock(); + v_iNextRowIndex = m_mNextRows[v_sImageNames[v_iIndex]]; + m_psThreadSynchEL->Unlock(); + + while (v_iNextRowIndex < v_iHeight) { + m_psThreadSynchEL->Lock(); + v_iNextRowIndex = m_mNextRows[v_sImageNames[v_iIndex]]; + m_mNextRows[v_sImageNames[v_iIndex]] += v_iBlockHeight; + m_rProgress = 100.0*((mmReal)v_iNextRowIndex/(mmReal)v_iHeight)*((mmReal)(v_iIndex + 1)/(mmReal)v_sImageNames.size()); + if (m_mNextRows[v_sImageNames[v_iIndex]] > v_iHeight) { + m_mNextRows[v_sImageNames[v_iIndex]] = v_iHeight; + v_iBlockHeight = v_iHeight - v_iNextRowIndex; + } + if (v_iNextRowIndex == 0) { + ExecBeforeSingleImageCalc(v_psLocalCurrentImage); + v_bNewImage = true; + m_bFinishImage = false; + } + else v_bNewImage = false; + m_psThreadSynchEL->Unlock(); + + (*p_psKernel)(v_psLocalCurrentImage, + v_iNextRowIndex, + v_iBlockHeight); + + m_psThreadSynchEL->Lock(); + v_iNextRowIndex = m_mNextRows[v_sImageNames[v_iIndex]]; + if (v_iNextRowIndex >= v_iHeight && !m_bFinishImage) { + v_bFinishImage = true; + m_bFinishImage = true; + ExecAfterSingleImageCalc(v_psLocalCurrentImage); + } + else { + v_bFinishImage = false; + } + m_psThreadSynchEL->Unlock(); + } + } + + m_psThreadSynchEL->Lock(); + m_iThreadsCount--; + /*if (m_iThreadsCount <= 0) { + m_psImageStructure->LockForRead(); + m_psImageStructure->UpdateImages(); + m_psImageStructure->UnlockFromRead(); + }*/ + m_psThreadSynchEL->Unlock(); +} + +void mmImages::mmCalcMethod::SetParam(mmString p_sName, mmXML::mmXMLDataType p_eType, void* p_psValue, bool p_bIsOutput) +{ + std::vector::iterator v_it; + for (v_it = m_vParameters.begin(); v_it != m_vParameters.end(); ++v_it) { + if (p_sName.compare((*v_it).m_sName) == 0) { + return; + } + } + mmCMParameter v_sParam(p_sName, p_eType, p_psValue, p_bIsOutput); + m_vParameters.push_back(v_sParam); +} + +const void* mmImages::mmCalcMethod::GetParam(mmString p_sName) +{ + std::vector::iterator v_it; + for (v_it = m_vParameters.begin(); v_it != m_vParameters.end(); ++v_it) { + if (p_sName.compare((*v_it).m_sName) == 0) { + return (*v_it).m_pValue.get(); + } + } + return NULL; +} + +void mmImages::mmCalcMethod::GetParam(mmString p_sName, void* p_pValue) +{ + std::vector::iterator v_it; + + for (v_it = m_vParameters.begin(); v_it != m_vParameters.end(); ++v_it) { + if (p_sName.compare((*v_it).m_sName) == 0) { + switch ((*v_it).m_eType) { + case mmXML::g_eXMLReal: + *(reinterpret_cast(p_pValue)) = *(reinterpret_cast((*v_it).m_pValue.get())); + return; + case mmXML::g_eXMLInt: + *(reinterpret_cast(p_pValue)) = *(reinterpret_cast((*v_it).m_pValue.get())); + return; + case mmXML::g_eXMLBool: + *(reinterpret_cast(p_pValue)) = *(reinterpret_cast((*v_it).m_pValue.get())); + return; + case mmXML::g_eXMLString: + case mmXML::g_eXMLImageName: + case mmXML::g_eXMLDataLayerName: + *(reinterpret_cast(p_pValue)) = *(reinterpret_cast((*v_it).m_pValue.get())); + return; + } + } + } +} + +void mmImages::mmCalcMethod::UpdateParameters() +{ + // create XML document which stores input automation options + std::auto_ptr v_psXMLInDoc(mmInterfaceInitializers::CreateXMLDocument(GetLogReceiver())); + mmXML::mmXMLPositionedNode v_sXMLInRootPosNode = mmXML::CreateAutomationInput(v_psXMLInDoc.get()); + + // create XML document which stores output automation options + std::auto_ptr v_psXMLOutDoc(mmInterfaceInitializers::CreateXMLDocument(GetLogReceiver())); + mmXML::mmXMLPositionedNode v_sXMLOutRootPosNode = mmXML::CreateAutomationOutput(v_psXMLOutDoc.get()); + + std::vector::iterator v_it; + for (v_it = m_vParameters.begin(); v_it != m_vParameters.end(); ++v_it) { + if ((*v_it).m_bIsOutput) { + (*v_it).m_sPosition = mmXML::AddParam(&v_sXMLOutRootPosNode, + (*v_it).m_sName, + (*v_it).m_eType, + (*v_it).m_pValue.get()); + } + else { + (*v_it).m_sPosition = mmXML::AddParam(&v_sXMLInRootPosNode, + (*v_it).m_sName, + (*v_it).m_eType, + (*v_it).m_pValue.get()); + } + } + + mmXML::CopyInputParams(v_psXMLInDoc.get(), &m_sCMParams.sAutoParams); + mmXML::CopyOutputParams(v_psXMLOutDoc.get(), &m_sCMParams.sAutoParams); +} + +std::vector mmImages::mmCalcMethod::GetImageNames() +{ + std::vector v_vResultCloudNames; + + // TODO: to trzeba zrobic jakos ladniej jesli uzupelniona zostanie funkcja GetXMLParameters() + + //m_psImageStructure->LockForRead(); + mmUInt v_iImageCount = m_psImageStructure->GetImageCount(); + for(mmUInt i = 0; i < v_iImageCount; ++i) { + v_vResultCloudNames.push_back(m_psImageStructure->GetImage(i)->GetName()); + } + //m_psImageStructure->UnlockFromRead(); + + return v_vResultCloudNames; +} + +std::vector mmImages::mmCalcMethod::GetDLNames(mmUInt const p_iImage) +{ + std::vector v_sResultDLNames; + + mmImageI* v_psImage = m_psImageStructure->GetImage(p_iImage); + if(! v_psImage) + return v_sResultDLNames; + + //v_psImage->LockForRead(); + mmUInt v_iDLCount = v_psImage->GetLayerCount(); + for(mmUInt i = 0; i < v_iDLCount; ++i) { + v_sResultDLNames.push_back(v_psImage->GetLayer(i)->GetName()); + } + //v_psImage->UnlockFromRead(); + + return v_sResultDLNames; +} diff --git a/proj/libcalc2d/src/images/mmImagesCalculationManagement.cpp b/proj/libcalc2d/src/images/mmImagesCalculationManagement.cpp new file mode 100644 index 0000000..a93cfcd --- /dev/null +++ b/proj/libcalc2d/src/images/mmImagesCalculationManagement.cpp @@ -0,0 +1,255 @@ +#include + +#include +#include + + + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmImages::mmImagesCalculationManagement +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmImages::mmImagesCalculationManagement::mmImagesCalculationManagement(mmInt p_iCalcThreadCount, mmLog::mmLogReceiverI *p_psLogReceiver = NULL): + mmLog::mmLogSender(L"mmImages::mmImagesCalculationManagement",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + + m_bIsActiveCalculation = false; + m_iCalculationThreadCount = p_iCalcThreadCount; + + m_iThreadExecutionSleepTime = 10; + //m_psControlThread = mmInterfaceInitializers::CreateDefaultThread(GetLogReceiver()); + m_psControlThread = mmInterfaceInitializers::CreateDefaultThread(NULL); + m_psControlThread->RegisterThreadExecutionClass(this); + m_psControlThread->Run(); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmImages::mmImagesCalculationManagement::~mmImagesCalculationManagement() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + m_psControlThread->Stop(); + while(m_psControlThread->GetStatus() != mmThread::mmThreadI::finished) + { + mmOperatingSystem::StopThread(1); + }; + delete m_psControlThread; + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + + +void mmImages::mmImagesCalculationManagement::StopRunningThreads(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start StopRunningThreads")); + + mmInt v_iActiveThreadCount = m_vRunningThreads.size(); + for(mmInt v_iT=0;v_iTStop(); + }; + + SendLogMessage(mmLog::debug,mmString(L"End StopRunningThreads")); +} + +bool mmImages::mmImagesCalculationManagement::IsCalculating(void) +{ +// SendLogMessage(mmLog::debug,mmString(L"Start IsCalculating")); + +// SendLogMessage(mmLog::debug,mmString(L"End IsCalculating")); + + return m_bIsActiveCalculation; +} + + +void mmImages::mmImagesCalculationManagement::CalculateImages( mmImages::mmImagesCalculationMethodI* p_psImagesCalculationMethod, + mmImages::mmImageStructureI* p_psImageStructure, + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start CalculateImages")); + + p_psImagesCalculationMethod->SetCalculationMethodParameters( p_psImageStructure, + p_psAutomationParams); + + m_bIsActiveCalculation = true; + + m_psImageStructure = p_psImageStructure; + if(p_psImagesCalculationMethod->GetCalculationMethodInfo().bIsMultithreaded) + { + //m_psImageStructure->InitializeForMultithreadedCalculation(m_iCalculationThreadCount); + + for(mmInt v_iT=0;v_iTRegisterThreadExecutionClass(p_psImagesCalculationMethod); + v_psThread->Run(); + + m_vRunningThreads.push_back(v_psThread); + }; + } + else + { + //m_psImageStructure->InitializeForMultithreadedCalculation(1); + + mmThread::mmThreadI* v_psThread = mmInterfaceInitializers::CreateDefaultThread(NULL); + v_psThread->RegisterThreadExecutionClass(p_psImagesCalculationMethod); + v_psThread->Run(); + + m_vRunningThreads.push_back(v_psThread); + }; + + SendLogMessage(mmLog::debug,mmString(L"End CalculateImages")); +} + +bool mmImages::mmImagesCalculationManagement::Execute(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Execute")); + + mmInt v_iThreadExecutionProgressUpdateFromLastTime = 0; + + mmReal v_rPrevProgress = 0.0; + + mmReal v_rCalculationStart = 0.0; + + m_bTerminateControlThreadExecution = false; + + while(!m_bTerminateControlThreadExecution) + { + if(m_bIsActiveCalculation) + { + mmInt v_iActiveThreadCount = m_vRunningThreads.size(); + mmInt v_iWorkingThreadCount = 0; + + // check working threads + if(v_iActiveThreadCount > 0) + { + mmReal v_rProgress = 0.0; + bool v_bIsCalculating = false; + for(mmInt v_iT=0;v_iTGetStatus(); + + if( (v_eTS != mmThread::mmThreadI::stopped) && + (v_eTS != mmThread::mmThreadI::finished) ) + { + v_bIsCalculating = true; + v_iWorkingThreadCount++; + }; + + v_rProgress += m_vRunningThreads[v_iT]->GetProgress(); + }; + //v_rProgress = v_rProgress/static_cast(v_iActiveThreadCount); + v_rProgress = v_rProgress/static_cast(v_iWorkingThreadCount); + //v_rProgress = m_vRunningThreads[0]->GetProgress(); + if(v_rProgress >= v_rPrevProgress) + { + v_rPrevProgress = v_rProgress; + m_rProgress = v_rProgress; + } + else + { + v_rProgress = v_rPrevProgress; + m_rProgress = v_rPrevProgress; + }; + + + if(!v_bIsCalculating) + { + + + mmReal v_rActCalculationTime = mmOperatingSystem::GetApplicationTime(); + mmReal v_rElapsed = v_rActCalculationTime - v_rCalculationStart; + + SendLogMessage(mmLog::user,mmString(L"Operation ") + mmString(L": ") + + mmStringUtilities::MMRealToString(v_rElapsed,3) + mmString(L"s")); + + + for(mmInt v_iT=0;v_iTDeinitializeForMultithreadedCalculation(); + + m_bIsActiveCalculation = false; + }; + }; + }; + + mmOperatingSystem::StopThread(m_iThreadExecutionSleepTime); + + v_iThreadExecutionProgressUpdateFromLastTime += m_iThreadExecutionSleepTime; + }; + + SendLogMessage(mmLog::debug,mmString(L"End Execute")); + + return true; +} + +void mmImages::mmImagesCalculationManagement::StopExecution(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start StopExecution")); + + m_bTerminateControlThreadExecution = true; + + SendLogMessage(mmLog::debug,mmString(L"End StopExecution")); +} + +bool mmImages::mmImagesCalculationManagement::IsExecuting(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start IsExecuting")); + + SendLogMessage(mmLog::debug,mmString(L"End IsExecuting")); + + return !m_bTerminateControlThreadExecution; +} + +mmReal mmImages::mmImagesCalculationManagement::GetProgress(void) +{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetProgress")); +// +// SendLogMessage(mmLog::debug,mmString(L"End GetProgress")); + + return m_rProgress; +} + +void mmImages::mmImagesCalculationManagement::UserAction(mmString p_sXMLParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UserAction")); + + // create XML document which specifies user action response + mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psXMLDoc->ParseXMLBuffer(p_sXMLParams); + mmXML::mmXMLNodeI* v_psUIRootNode = v_psXMLDoc->GetXMLRootNode(); + +// // parsing user actions +// mmString v_sUserActionID = v_psUIRootNode->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText(); +// +// if(v_sUserActionID.compare(mmImages::g_pXML_Progress_CancelButton) == 0) +// { +// // stop threads +// StopRunningThreads(); +// }; + + SendLogMessage(mmLog::debug,mmString(L"End UserAction")); +} + +void mmImages::mmImagesCalculationManagement::UserAction(wchar_t* p_pcXMLParamsBuffer, mmInt p_iXMLParamsBufferSize ) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UserAction")); + + UserAction(p_pcXMLParamsBuffer); + + SendLogMessage(mmLog::debug,mmString(L"End UserAction")); +} + diff --git a/proj/libcalc2d/src/images/mmImagesCalculationMethodContainerWindows.cpp b/proj/libcalc2d/src/images/mmImagesCalculationMethodContainerWindows.cpp new file mode 100644 index 0000000..eeb3d30 --- /dev/null +++ b/proj/libcalc2d/src/images/mmImagesCalculationMethodContainerWindows.cpp @@ -0,0 +1,163 @@ +#include + +#include +#include +#include +#include + +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmImages::mmImagesCalculationMethodContainerForWindows +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmImages::mmImagesCalculationMethodContainerForWindows::mmImagesCalculationMethodContainerForWindows(mmLog::mmLogReceiverI *p_psLogReceiver): mmLog::mmLogSender(L"mmImages::mmImagesCalculationMethodContainerForWindows",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + SearchForDLLLibraries(); + SearchForImagesCalculationMethodsInDLLLibraries(); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmImages::mmImagesCalculationMethodContainerForWindows::~mmImagesCalculationMethodContainerForWindows() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +std::vector mmImages::mmImagesCalculationMethodContainerForWindows::GetAvailableImagesCalculationMethods(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetAvailableImagesCalculationMethods")); + + std::vector v_vDefsOfKnownImagesCalculationMethods; + + mmInt v_iDLL,v_iImp,v_iImpCount; + mmInt v_iDLLCount = m_vAvailableDLLs.size(); + for(v_iDLL=0;v_iDLLGetLogReceiver()); + + // clear existing detectors definition + m_vAvailableDLLs.clear(); + + sImagesCalculationMethodInDLL v_sDLLDef; + + mmString v_sAppDir = v_psFileUtils->GetApplicationDir(); + std::vector v_vApplicationDirElements = v_psFileUtils->GetDirElements(v_sAppDir,L"*.dll"); + + mmInt v_iTemp; + mmInt v_iDirElementsCount = v_vApplicationDirElements.size(); + for(v_iTemp=0;v_iTemp 0) + { + HINSTANCE v_hDLL = LoadLibrary(m_vAvailableDLLs[v_iTemp].sDLLName.c_str()); + + mmString v_sDLLNameTemp = m_vAvailableDLLs[v_iTemp].sDLLName; + + mmDLLGetSupportedImagesCalculationMethodCount v_pfGetSupportedImagesCalculationMethodsCount = (mmDLLGetSupportedImagesCalculationMethodCount)GetProcAddress(v_hDLL, + mmStringUtilities::MMStringToCharString(v_sSymbolDLL_ImagesCalculationMethodsCount).c_str()); + + mmDLLGetSupportedImagesCalculationMethodDef v_pfGetSupportedImagesCalculationMethodDef = (mmDLLGetSupportedImagesCalculationMethodDef)GetProcAddress(v_hDLL, + mmStringUtilities::MMStringToCharString(v_sSymbolDLL_ImagesCalculationMethodDef).c_str()); + + if(v_pfGetSupportedImagesCalculationMethodsCount != NULL) + { + mmImages::mmImagesCalculationMethodI::sCalculationMethodParams v_sCMP; + mmInt v_iImp; + mmInt v_iImpCount = v_pfGetSupportedImagesCalculationMethodsCount(); + //char v_pcTemp[256]; + + for(v_iImp=0;v_iImp + +#include +#include +#include + +mmImages::mmImagesCalculationMethodDLLBroker::mmImagesCalculationMethodDLLBroker(mmString p_sDLLName, + mmString p_sImagesCalculationMethodName, + + mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmImages::mmImagesCalculationMethodDLLBroker",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + // restoring functions symbols from DLL + mmString v_sDLLSymbol_mmDLLImagesCalculationMethod_Create = mmDLLSupport::FindSymbolInDLLExportTable(p_sDLLName, + L"mmDLLCreateImagesCalculationMethod"); + mmString v_sDLLSymbol_mmDLLImagesCalculationMethod_Destroy = mmDLLSupport::FindSymbolInDLLExportTable(p_sDLLName, + L"mmDLLDestroyImagesCalculationMethod"); + + // loading images calculation method dll + m_hDLLHandle = LoadLibrary(p_sDLLName.c_str()); + + // storing pointer to images calculation method functions + m_psDLLImagesCalculationMethod_Create = (mmDLLImagesCalculationMethod_Create)GetProcAddress(m_hDLLHandle, + mmStringUtilities::MMStringToCharString(v_sDLLSymbol_mmDLLImagesCalculationMethod_Create).c_str()); + m_psDLLImagesCalculationMethod_Destroy = (mmDLLImagesCalculationMethod_Destroy)GetProcAddress(m_hDLLHandle, + mmStringUtilities::MMStringToCharString(v_sDLLSymbol_mmDLLImagesCalculationMethod_Destroy).c_str()); + + // initialize images calculation method + mmInterfacesStorage::mmGlobalInterfacesStorage v_sInterfacesStorage(p_psLogReceiver ); + m_psInitializedImagesCalculationMethod = m_psDLLImagesCalculationMethod_Create(&v_sInterfacesStorage,p_sImagesCalculationMethodName.c_str()); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmImages::mmImagesCalculationMethodDLLBroker::~mmImagesCalculationMethodDLLBroker() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + // destroy images calculation method + m_psDLLImagesCalculationMethod_Destroy(m_psInitializedImagesCalculationMethod); + + // free images calculation method dll + FreeLibrary(m_hDLLHandle); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +mmImages::mmImagesCalculationMethodI::sCalculationMethodParams mmImages::mmImagesCalculationMethodDLLBroker::GetCalculationMethodInfo(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetCalculationMethodInfo")); + + mmImages::mmImagesCalculationMethodI::sCalculationMethodParams v_sCMP = m_psInitializedImagesCalculationMethod->GetCalculationMethodInfo(); + + SendLogMessage(mmLog::debug,mmString(L"End GetCalculationMethodInfo")); + + return v_sCMP; +} + +void mmImages::mmImagesCalculationMethodDLLBroker::SetCalculationMethodParameters(mmImages::mmImageStructureI* p_psImageStructure, + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetCalculationMethodParameters")); + + m_psInitializedImagesCalculationMethod->SetCalculationMethodParameters(p_psImageStructure,p_psAutomationParams); + + SendLogMessage(mmLog::debug,mmString(L"End SetCalculationMethodParameters")); +} + +void mmImages::mmImagesCalculationMethodDLLBroker::UserAction(mmString p_sXMLParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UserAction")); + + UserAction(const_cast(p_sXMLParams.c_str()),p_sXMLParams.size()); + + SendLogMessage(mmLog::debug,mmString(L"End UserAction")); +} + +void mmImages::mmImagesCalculationMethodDLLBroker::UserAction(wchar_t* p_pcXMLParamsBuffer, + mmInt p_iXMLParamsBufferSize) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UserAction")); + + //m_psInitializedImagesCalculationMethod->UserAction(p_pcXMLParamsBuffer,p_iXMLParamsBufferSize); + + SendLogMessage(mmLog::debug,mmString(L"End UserAction")); +} + +bool mmImages::mmImagesCalculationMethodDLLBroker::Execute(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Execute")); + + bool v_bRes = m_psInitializedImagesCalculationMethod->Execute(); + + SendLogMessage(mmLog::debug,mmString(L"End Execute")); + + return v_bRes; +} + +void mmImages::mmImagesCalculationMethodDLLBroker::StopExecution(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start StopExecution")); + + m_psInitializedImagesCalculationMethod->StopExecution(); + + SendLogMessage(mmLog::debug,mmString(L"End StopExecution")); +} + +bool mmImages::mmImagesCalculationMethodDLLBroker::IsExecuting(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start IsExecuting")); + + bool v_bIsExecuting = m_psInitializedImagesCalculationMethod->IsExecuting(); + + SendLogMessage(mmLog::debug,mmString(L"End IsExecuting")); + + return v_bIsExecuting; +} + +mmReal mmImages::mmImagesCalculationMethodDLLBroker::GetProgress(void) +{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetProgress")); + + mmReal v_rProgress = m_psInitializedImagesCalculationMethod->GetProgress(); + +// SendLogMessage(mmLog::debug,mmString(L"End GetProgress")); + + return v_rProgress; +} + + diff --git a/proj/libcalc2d/src/images/mmImagesComplexCalculationManagement.cpp b/proj/libcalc2d/src/images/mmImagesComplexCalculationManagement.cpp new file mode 100644 index 0000000..c56c71e --- /dev/null +++ b/proj/libcalc2d/src/images/mmImagesComplexCalculationManagement.cpp @@ -0,0 +1,3320 @@ +#include + +#include +#include + +const wchar_t* mmImages::g_pComplexCalcXML_PatternContainer_Node = L"ComplexPatternContainer"; + +const wchar_t* mmImages::g_pComplexCalcXML_Pattern_Node = L"ComplexPattern"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternName_Node = L"Name"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternIDName_Node = L"IDName"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternDescription_Node = L"Description"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParams_Node = L"InputParams"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParam_Node = L"InputParam"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParam_Constant_Attr = L"ConstParam"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamName_Node = L"InputParamName"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamType_Node = L"InputParamType"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamValue_Node = L"InputParamValue"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamValueModifiedNodeName_Node = L"InputParamModified"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParams_Node = L"OutputParams"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParam_Node = L"OutputParam"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParamName_Node = L"OutputParamName"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParamType_Node = L"OutputParamType"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParamValue_Node = L"OutputParamValue"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParamValueModifiedNodeName_Node = L"OutputParamModified"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParamValueModifiedSecondNodeName_Node = L"SecondOutputParamModified"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node = L"OutputParamOperation"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternDefinition_Node = L"PatternDefinition"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternCalcMethod_Node = L"CalculationMethod"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternCalcMethodIDName_Node = L"CalculationMethodIDName"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInternalAction_Node = L"InternalAction"; + const wchar_t* mmImages::g_pComplexCalcXML_PatternInternalActionName_Node = L"InternalActionName"; + +// PB // +//const wchar_t* mmImages::g_pComplexCalcXML_Action_AddSimpleCalculationMethod = L"Add Calculation Method"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_AddOutputValueFromExisting = L"Add Modified Output Value"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_MixOutputValuesFromExisting = L"Mix Output Values"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_AddInputValueFromExistingOrConst = L"Add Constant/Modified Input Value"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_AddInputValueConstDecision = L"Add Input Decision Value"; + +// PB // +//const wchar_t* mmImages::g_pComplexCalcXML_Action_AddWhileLoop = L"Add WHILE loop"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_AddEndWhile = L"Add END_WHILE"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_CopyBinaryOutputToInputValue = L"Copy Decision From Output To Input Value"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_CopyIntOutputToInputValue = L"Copy Int From Output To Input Value"; +//const wchar_t* mmImages::g_pComplexCalcXML_Action_CopyRealOutputToInputValue = L"Copy Real From Output To Input Value"; + +// PB // +//const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamUserSpecified = L"[User_Specified]"; +//const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamConstant_Real = L"[Constant_Real]"; +//const wchar_t* mmImages::g_pComplexCalcXML_PatternInputParamConstant_Int = L"[Constant_Int]"; + +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Addition = L"Addition"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Subtraction = L"Subtraction"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Multiplication = L"Multiplication"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Division = L"Division"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Power = L"Power"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Minimum = L"Minimum"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Maximum = L"Maximum"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Equal = L"Equal"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Less = L"Less"; +const wchar_t* mmImages::g_pComplexCalcXML_PatternOutputFormula_Greater = L"Greater"; + +mmImages::mmImagesComplexCalculationManagement::mmImagesComplexCalculationManagement( mmImages::mmImagesCalculationMethodContainerI* p_psImageCalculationMethodContainer, + mmImages::mmImagesCalculationManagement* p_psImageCalculationManagement, + mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmImages::mmImagesComplexCalculationManagement",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + m_psImageCalculationMethodContainer = p_psImageCalculationMethodContainer; + m_psImageCalculationManagement = p_psImageCalculationManagement; + + m_vSimpleCalculationMethodsInfo = p_psImageCalculationMethodContainer->GetAvailableImagesCalculationMethods(); + + m_psXMLCurrentPatternDefinition = NULL; + m_bIsNew = true; + m_psXMLCalculatedPatternDefinition = NULL; + + m_sComplexPatternContainerXMLFile = mmOperatingSystem::GetApplicationDirectory() + + mmString(L"\\ComplexPatterns.icpxml"); + m_psXMLComplexPatternContainer = NULL; + LoadComplexPatternsFromFile(m_sComplexPatternContainerXMLFile); + +// PB // +// m_hUIActiveDialog = -1; + + m_bIsActiveCalculation = false; + + m_psStateChangeReceiver = NULL; + + //m_psThreadSynchronizationEL = mmInterfaceInitializers::CreateExclusiveLock(GetLogReceiver()); + m_psThreadSynchronizationEL = mmInterfaceInitializers::CreateExclusiveLock(NULL); + + m_iThreadExecutionSleepTime = 10; + //m_psControlThread = mmInterfaceInitializers::CreateDefaultThread(GetLogReceiver()); + m_psControlThread = mmInterfaceInitializers::CreateDefaultThread(NULL); + m_psControlThread->RegisterThreadExecutionClass(this); + m_psControlThread->Run(); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmImages::mmImagesComplexCalculationManagement::~mmImagesComplexCalculationManagement() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + m_psControlThread->Stop(); + while(m_psControlThread->GetStatus() != mmThread::mmThreadI::finished) + { + mmOperatingSystem::StopThread(1); + }; + delete m_psControlThread; + + if( m_psXMLComplexPatternContainer ) + delete m_psXMLComplexPatternContainer; + + delete m_psThreadSynchronizationEL; + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +mmInt mmImages::mmImagesComplexCalculationManagement::GetCountOfComplexCalculationPatterns(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetCountOfComplexCalculationPatterns")); + + mmInt v_iCCPCount = 0; + + std::vector v_vCCPNodes = m_psXMLComplexPatternContainer->GetXMLRootNode()->GetChilds(); + v_iCCPCount = v_vCCPNodes.size(); + + SendLogMessage(mmLog::debug,mmString(L"End GetCountOfComplexCalculationPatterns")); + + return v_iCCPCount; +} + +mmImages::mmImagesComplexCalculationManagement::sComplexCalculationInfo + mmImages::mmImagesComplexCalculationManagement::GetComplexCalculationPatternInfo(mmInt p_iPatternID) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetComplexCalculationPatternInfo")); + + mmImages::mmImagesComplexCalculationManagement::sComplexCalculationInfo v_sCCPI; + + v_sCCPI.sName = m_psXMLComplexPatternContainer-> + GetXMLRootNode()-> + GetChild(p_iPatternID)-> + FindChild(mmImages::g_pComplexCalcXML_PatternName_Node)-> + GetText(); + v_sCCPI.sIDName = m_psXMLComplexPatternContainer-> + GetXMLRootNode()-> + GetChild(p_iPatternID)-> + FindChild(mmImages::g_pComplexCalcXML_PatternIDName_Node)-> + GetText(); + v_sCCPI.sDescription = m_psXMLComplexPatternContainer-> + GetXMLRootNode()-> + GetChild(p_iPatternID)-> + FindChild(mmImages::g_pComplexCalcXML_PatternDescription_Node)-> + GetText(); + + SendLogMessage(mmLog::debug,mmString(L"End GetComplexCalculationPatternInfo")); + + return v_sCCPI; +} + +void mmImages::mmImagesComplexCalculationManagement::ExecuteComplexCalculationPattern( mmString p_sPatternIDName, + mmImages::mmImageStructureI* p_psImageStructure) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ExecuteComplexCalculationPattern")); + + sComplexCalculationDefinition v_sCCD; + v_sCCD.sIDName = p_sPatternIDName; + v_sCCD.psImageStructure = p_psImageStructure; + + // add pattern to execute list + m_psThreadSynchronizationEL->Lock(); + m_vCalculationSheme.push_back(v_sCCD); + m_psThreadSynchronizationEL->Unlock(); + + SendLogMessage(mmLog::debug,mmString(L"End ExecuteComplexCalculationPattern")); +} + +void mmImages::mmImagesComplexCalculationManagement::RegisterStateChangeReceiver(mmImagesComplexCalculationManagementStateChangeReceiverI* p_psStateChangeReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start RegisterStateChangeReceiver")); + + m_psStateChangeReceiver = p_psStateChangeReceiver; + + SendLogMessage(mmLog::debug,mmString(L"End RegisterStateChangeReceiver")); +} + +void mmImages::mmImagesComplexCalculationManagement::UnregisterStateChangeReceiver(mmImagesComplexCalculationManagementStateChangeReceiverI* p_psStateChangeReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UnregisterStateChangeReceiver")); + + m_psStateChangeReceiver = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End UnregisterStateChangeReceiver")); +} + +bool mmImages::mmImagesComplexCalculationManagement::IsCalculating(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start IsCalculating")); + + SendLogMessage(mmLog::debug,mmString(L"End IsCalculating")); + + return m_bIsActiveCalculation; +} + +bool mmImages::mmImagesComplexCalculationManagement::Execute(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Execute")); + + mmReal v_rCalculationStart; + + m_bTerminateControlThreadExecution = false; + + while(!m_bTerminateControlThreadExecution) + { + if(m_bIsActiveCalculation) + { + m_bIsActiveCalculation = !ManageCurrentComplexCalculationPatternExecution(); + } + else + { + // check if are some patterns to execute + m_psThreadSynchronizationEL->Lock(); + if(m_vCalculationSheme.size() > 0) + { + m_sCurrentComplexCalculation = m_vCalculationSheme.front(); + m_vCalculationSheme.pop_front(); + + m_psXMLCalculatedPatternDefinition = GetComplexCalculationPatternDefinition(m_sCurrentComplexCalculation.sIDName); + m_iCurrentComplexCalculationItem = -1; + }; + m_psThreadSynchronizationEL->Unlock(); + + // execute them + if(m_psXMLCalculatedPatternDefinition != NULL) + { +// PB // +// InitializeCurrentComplexCalculationPatternExecution(); + + m_bIsActiveCalculation = !ManageCurrentComplexCalculationPatternExecution(); + }; + }; + + mmOperatingSystem::StopThread(m_iThreadExecutionSleepTime); + }; + + SendLogMessage(mmLog::debug,mmString(L"End Execute")); + + return true; +} + +void mmImages::mmImagesComplexCalculationManagement::StopExecution(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start StopExecution")); + + m_bTerminateControlThreadExecution = true; + + SendLogMessage(mmLog::debug,mmString(L"End StopExecution")); +} + +bool mmImages::mmImagesComplexCalculationManagement::IsExecuting(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start IsExecuting")); + + SendLogMessage(mmLog::debug,mmString(L"End IsExecuting")); + + return !m_bTerminateControlThreadExecution; +} + +mmReal mmImages::mmImagesComplexCalculationManagement::GetProgress(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetProgress")); + + SendLogMessage(mmLog::debug,mmString(L"End GetProgress")); + + return 0.0; +} + +// PB // +//mmImages::mmImagesCalculationMethodI::sCalculationMethodParams* +// mmImages::mmImagesComplexCalculationManagement::GetCalculationMethodInfo(mmString p_sCalculationMethodIDName) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetCalculationMethodInfo")); +// +// mmInt v_iCMCount = m_vSimpleCalculationMethodsInfo.size(); +// for(mmInt v_iCM=0;v_iCMGetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // parse string +// v_psXMLDoc->ParseXMLBuffer(p_psInOutParams); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// std::vector v_vInputParams = v_psRootNode->GetChild(1)->GetChilds(); +// mmInt v_iIPCount = v_vInputParams.size(); +// for(mmInt v_iIP=1;v_iIP v_vOrigAttrParams = v_vInputParams[v_iIP]->GetAttributes(); +// +// if(v_vOrigAttrParams.size() > 0) +// { +// if(v_vOrigAttrParams[1].sValue.compare(mmImages::g_pAutoCalcXML_Params_ParamType_ImagesNames) == 0) +// { +// +// std::vector v_vClNamesVals = +// mmStringUtilities::MMStringToVectorOfMMString( v_vInputParams[v_iIP]-> +// FindChild(mmUI::g_pUIXML_EL_DEF_Value)-> +// GetText()); +// +// // DEBUG +// //mmInt v_iNCount = v_vClNamesVals.size(); +// //for(mmInt v_iN=0;v_iNGetChild(0)->GetText(), +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText() + +// mmString(L" - Cloud ") + +// mmStringUtilities::MMIntToString(v_iC+1)); +// +// v_vClNamesVals[v_iC+1] = v_sNewInputParamName; +// +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Name = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node); +// v_psNewPattern_InputValues_NewNode_Name->SetText(v_sNewInputParamName); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Type = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node); +// v_psNewPattern_InputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Value = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node); +// v_psNewPattern_InputValues_NewNode_Value->SetText(v_sNewInputParamName); +// }; +// }; +// +// mmString v_sFinalCloudNames = v_vClNamesVals[0]; +// mmInt v_iNCount = v_vClNamesVals.size(); +// for(mmInt v_iN=1;v_iNFindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sFinalCloudNames); +// }; +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// if(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText().compare(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified) == 0) +// { +// mmString v_sNewInputParamName = GetFromUIReadableInputParameterName(L"Write input parameter name", +// v_psRootNode->GetChild(0)->GetText(), +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sNewInputParamName); +// +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Name = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node); +// v_psNewPattern_InputValues_NewNode_Name->SetText(v_sNewInputParamName); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Type = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node); +// v_psNewPattern_InputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Value = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node); +// v_psNewPattern_InputValues_NewNode_Value->SetText(v_sNewInputParamName); +// }; +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// if(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText().compare(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified) == 0) +// { +// mmString v_sNewInputParamName = GetFromUIReadableInputParameterName(L"Write input parameter name", +// v_psRootNode->GetChild(0)->GetText(), +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sNewInputParamName); +// +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Name = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node); +// v_psNewPattern_InputValues_NewNode_Name->SetText(v_sNewInputParamName); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Type = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node); +// v_psNewPattern_InputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Value = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node); +// v_psNewPattern_InputValues_NewNode_Value->SetText(v_sNewInputParamName); +// }; +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// if(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText().compare(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified) == 0) +// { +// mmString v_sNewInputParamName = GetFromUIReadableInputParameterName(L"Write input parameter name", +// v_psRootNode->GetChild(0)->GetText(), +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sNewInputParamName); +// +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Name = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node); +// v_psNewPattern_InputValues_NewNode_Name->SetText(v_sNewInputParamName); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Type = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node); +// v_psNewPattern_InputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Value = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node); +// v_psNewPattern_InputValues_NewNode_Value->SetText(v_sNewInputParamName); +// }; +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// if(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText().compare(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified) == 0) +// { +// mmString v_sNewInputParamName = GetFromUIReadableInputParameterName(L"Write input parameter name", +// v_psRootNode->GetChild(0)->GetText(), +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sNewInputParamName); +// +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Name = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node); +// v_psNewPattern_InputValues_NewNode_Name->SetText(v_sNewInputParamName); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Type = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node); +// v_psNewPattern_InputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Value = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node); +// v_psNewPattern_InputValues_NewNode_Value->SetText(v_sNewInputParamName); +// }; +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// if(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText().compare(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified) == 0) +// { +// mmString v_sNewInputParamName = GetFromUIReadableInputParameterName(L"Write input parameter name", +// v_psRootNode->GetChild(0)->GetText(), +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sNewInputParamName); +// +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Name = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node); +// v_psNewPattern_InputValues_NewNode_Name->SetText(v_sNewInputParamName); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Type = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node); +// v_psNewPattern_InputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_InputValues_NewNode_Value = v_psNewPattern_InputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node); +// v_psNewPattern_InputValues_NewNode_Value->SetText(v_sNewInputParamName); +// }; +// }; +// }; +// }; +// +// std::vector v_vOutputParams = v_psRootNode->GetChild(2)->GetChilds(); +// mmInt v_iOPCount = v_vOutputParams.size(); +// for(mmInt v_iOP=1;v_iOP v_vOrigAttrParams = v_vOutputParams[v_iOP]->GetAttributes(); +// +// if(v_vOrigAttrParams.size() > 0) +// { +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Name = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node); +// v_psNewPattern_OutputValues_NewNode_Name->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Type = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node); +// v_psNewPattern_OutputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Value = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamValue_Node); +// v_psNewPattern_OutputValues_NewNode_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Name = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node); +// v_psNewPattern_OutputValues_NewNode_Name->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Type = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node); +// v_psNewPattern_OutputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Value = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamValue_Node); +// v_psNewPattern_OutputValues_NewNode_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Name = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node); +// v_psNewPattern_OutputValues_NewNode_Name->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Type = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node); +// v_psNewPattern_OutputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Value = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamValue_Node); +// v_psNewPattern_OutputValues_NewNode_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Name = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node); +// v_psNewPattern_OutputValues_NewNode_Name->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Type = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node); +// v_psNewPattern_OutputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Value = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamValue_Node); +// v_psNewPattern_OutputValues_NewNode_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParam_Node); +// // add name +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Name = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node); +// v_psNewPattern_OutputValues_NewNode_Name->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Type = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node); +// v_psNewPattern_OutputValues_NewNode_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue); +// // add value +// mmXML::mmXMLNodeI* v_psNewPattern_OutputValues_NewNode_Value = v_psNewPattern_OutputValues_NewNode->AddChild(mmClouds::g_pComplexCalcXML_PatternOutputParamValue_Node); +// v_psNewPattern_OutputValues_NewNode_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// }; +// }; +// +// mmString v_sOutXML = v_psXMLDoc->SaveToXMLBuffer(); +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End UpdateInputOutputParameters")); +// +// return v_sOutXML; +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::GetFromUIReadableInputParameterName( mmString p_sTitle, +// mmString p_sDescription, +// mmString p_sParamName) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetFromUIReadableInputParameterName")); +// +// // create XML document which specifies new input parameter name +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(p_sTitle); +// +// // add input param group node +// mmXML::mmXMLNodeI* v_psInParamGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psInParamGroupNodeName = v_psInParamGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psInParamGroupNodeName->SetText(p_sDescription); +// +// // add name field +// mmXML::mmXMLNodeI* v_psInParamName = v_psInParamGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psInParamNameName = v_psInParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psInParamNameName->SetText(p_sParamName); +// // type +// mmXML::mmXMLNodeI* v_psInParamNameType = v_psInParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psInParamNameType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psInParamNameValue = v_psInParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psInParamNameValue->SetText(L""); +// +// mmString v_sOutXML = m_psMainWindow->ShowModalDialog(v_psXMLDoc->SaveToXMLBuffer(),NULL); +// +// v_psXMLDoc->ParseXMLBuffer(v_sOutXML); +// v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// mmString v_sOutName = v_psRootNode->GetChild(1)->GetChild(1)->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText(); +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End GetFromUIReadableInputParameterName")); +// +// return v_sOutName; +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::CreateNewOutputValueFromExistingUI(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start CreateNewOutputValueFromExistingUI")); +// +// // create XML document which specifies new output parameter name +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(L"Modify existing output value"); +// +// // add output param group node +// mmXML::mmXMLNodeI* v_psGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psGroupNodeName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psGroupNodeName->SetText(L""); +// +// // add existing output value selection +// mmXML::mmXMLNodeI* v_psOutValSelection = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psOutValSelectionName = v_psOutValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psOutValSelectionName->SetText(L" Select output value to modify: "); +// // type +// mmXML::mmXMLNodeI* v_psOutValSelectionType = v_psOutValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psOutValSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psOutValSelectionRange = v_psOutValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psOutValSelectionRangeStringList = v_psOutValSelectionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// std::vector v_vOutParams = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->GetChilds(); +// mmInt v_iOPCount = v_vOutParams.size(); +// for(mmInt v_iOP=0;v_iOPFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOutValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// if(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOutValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// std::vector v_vInParams = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->GetChilds(); +// mmInt v_iIPCount = v_vInParams.size(); +// for(mmInt v_iIP=0;v_iIPFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOutValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// if(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOutValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// // value +// mmXML::mmXMLNodeI* v_psOutValSelectionValue = v_psOutValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psOutValSelectionValue->SetText(L""); +// +// // add formula input +// mmXML::mmXMLNodeI* v_psFormula = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psFormulaName = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psFormulaName->SetText(L" Set operation: "); +// // type +// mmXML::mmXMLNodeI* v_psFormulaType = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psFormulaType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psFormulaRange = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psFormulaRangeStringList = v_psFormulaRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Multiplication); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Division); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Power); +// // value +// mmXML::mmXMLNodeI* v_psFormulaValue = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psFormulaValue->SetText(L""); +// +// // add modification input +// mmXML::mmXMLNodeI* v_psMultVal = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psMultValName = v_psMultVal->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psMultValName->SetText(L" Set modification value: "); +// // type +// mmXML::mmXMLNodeI* v_psMultValType = v_psMultVal->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psMultValType->SetText(mmUI::g_pUIXML_EL_DEF_Type_Real); +// // value +// mmXML::mmXMLNodeI* v_psMultValValue = v_psMultVal->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psMultValValue->SetText(L"1.0"); +// +// // add name for new value +// mmXML::mmXMLNodeI* v_psNewParamName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psNewParamNameName = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psNewParamNameName->SetText(L" Set new name for output value: "); +// // type +// mmXML::mmXMLNodeI* v_psNewParamNameType = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psNewParamNameType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psNewParamNameValue = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psNewParamNameValue->SetText(L""); +// +// mmString v_sOutXML = v_psXMLDoc->SaveToXMLBuffer(); +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End CreateNewOutputValueFromExistingUI")); +// +// return v_sOutXML; +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::CreateNewOutputValueFromMixOfTwoExistingUI(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start CreateNewOutputValueFromMixOfTwoExistingUI")); +// +// // create XML document which specifies new output parameter name +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(L"Mix two existing output values"); +// +// // add output param group node +// mmXML::mmXMLNodeI* v_psGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psGroupNodeName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psGroupNodeName->SetText(L""); +// +// // add existing output 1st value selection +// mmXML::mmXMLNodeI* v_psOut1ValSelection = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psOut1ValSelectionName = v_psOut1ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psOut1ValSelectionName->SetText(L" Select 1st output value to modify: "); +// // type +// mmXML::mmXMLNodeI* v_psOut1ValSelectionType = v_psOut1ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psOut1ValSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psOut1ValSelectionRange = v_psOut1ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psOut1ValSelectionRangeStringList = v_psOut1ValSelectionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// std::vector v_vOutParams = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParams_Node)->GetChilds(); +// mmInt v_iOPCount = v_vOutParams.size(); +// for(mmInt v_iOP=0;v_iOPFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut1ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// if(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut1ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// std::vector v_vInParams = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->GetChilds(); +// mmInt v_iIPCount = v_vInParams.size(); +// for(mmInt v_iIP=0;v_iIPFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut1ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// if(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut1ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// // value +// mmXML::mmXMLNodeI* v_psOut1ValSelectionValue = v_psOut1ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psOut1ValSelectionValue->SetText(L""); +// +// // add existing output 2nd value selection +// mmXML::mmXMLNodeI* v_psOut2ValSelection = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psOut2ValSelectionName = v_psOut2ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psOut2ValSelectionName->SetText(L" Select 2nd output value to modify: "); +// // type +// mmXML::mmXMLNodeI* v_psOut2ValSelectionType = v_psOut2ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psOut2ValSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psOut2ValSelectionRange = v_psOut2ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psOut2ValSelectionRangeStringList = v_psOut2ValSelectionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iOP=0;v_iOPFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut2ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// if(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut2ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vOutParams[v_iOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iIP=0;v_iIPFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut2ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// if(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psOut2ValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// // value +// mmXML::mmXMLNodeI* v_psOut2ValSelectionValue = v_psOut2ValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psOut2ValSelectionValue->SetText(L""); +// +// // add formula input +// mmXML::mmXMLNodeI* v_psFormula = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psFormulaName = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psFormulaName->SetText(L" Set operation: "); +// // type +// mmXML::mmXMLNodeI* v_psFormulaType = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psFormulaType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psFormulaRange = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psFormulaRangeStringList = v_psFormulaRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Addition); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Subtraction); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Multiplication); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Division); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Minimum); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Maximum); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Equal); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Less); +// v_psUIStringListElement = v_psFormulaRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternOutputFormula_Greater); +// // value +// mmXML::mmXMLNodeI* v_psFormulaValue = v_psFormula->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psFormulaValue->SetText(L""); +// +// // add name for new value +// mmXML::mmXMLNodeI* v_psNewParamName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psNewParamNameName = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psNewParamNameName->SetText(L" Set new name for output value: "); +// // type +// mmXML::mmXMLNodeI* v_psNewParamNameType = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psNewParamNameType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psNewParamNameValue = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psNewParamNameValue->SetText(L""); +// +// mmString v_sOutXML = v_psXMLDoc->SaveToXMLBuffer(); +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End CreateNewOutputValueFromMixOfTwoExistingUI")); +// +// return v_sOutXML; +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::CreateNewConstantInputValueUI(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start CreateNewConstantInputValueUI")); +// +// // create XML document which specifies new input parameter name +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(L"Create/Modify existing input value"); +// +// // add input param group node +// mmXML::mmXMLNodeI* v_psGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psGroupNodeName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psGroupNodeName->SetText(L""); +// +// // add existing input value selection +// mmXML::mmXMLNodeI* v_psInValSelection = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psInValSelectionName = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psInValSelectionName->SetText(L" Select input value: "); +// // type +// mmXML::mmXMLNodeI* v_psInValSelectionType = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psInValSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psInValSelectionRange = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psInValSelectionRangeStringList = v_psInValSelectionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// std::vector v_vInParams = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->GetChilds(); +// mmInt v_iIPCount = v_vInParams.size(); +// for(mmInt v_iIP=0;v_iIPFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psInValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// if(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psInValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psInValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamConstant_Real); +// v_psUIStringListElement = v_psInValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamConstant_Int); +// // value +// mmXML::mmXMLNodeI* v_psInValSelectionValue = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psInValSelectionValue->SetText(L""); +// +// // add multiplication input +// mmXML::mmXMLNodeI* v_psMultVal = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psMultValName = v_psMultVal->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psMultValName->SetText(L" Set modification/constant value: "); +// // type +// mmXML::mmXMLNodeI* v_psMultValType = v_psMultVal->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psMultValType->SetText(mmUI::g_pUIXML_EL_DEF_Type_Real); +// // value +// mmXML::mmXMLNodeI* v_psMultValValue = v_psMultVal->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psMultValValue->SetText(L"1.0"); +// +// // add name for new value +// mmXML::mmXMLNodeI* v_psNewParamName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psNewParamNameName = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psNewParamNameName->SetText(L" Set new name for input value: "); +// // type +// mmXML::mmXMLNodeI* v_psNewParamNameType = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psNewParamNameType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psNewParamNameValue = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psNewParamNameValue->SetText(L""); +// +// mmString v_sOutXML = v_psXMLDoc->SaveToXMLBuffer(); +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End CreateNewConstantInputValueUI")); +// +// return v_sOutXML; +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::CreateNewConstantInputDecisionUI(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start CreateNewConstantInputDecisionUI")); +// +// // create XML document which specifies new input parameter name +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(L"Create input constant decision"); +// +// // add input param group node +// mmXML::mmXMLNodeI* v_psGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psGroupNodeName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psGroupNodeName->SetText(L""); +// +// // add existing input value selection +// mmXML::mmXMLNodeI* v_psInValSelection = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psInValSelectionName = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psInValSelectionName->SetText(L" Select input value: "); +// // type +// mmXML::mmXMLNodeI* v_psInValSelectionType = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psInValSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psInValSelectionRange = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psInValSelectionRangeStringList = v_psInValSelectionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psInValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue_YES); +// v_psUIStringListElement = v_psInValSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue_NO); +// // value +// mmXML::mmXMLNodeI* v_psInValSelectionValue = v_psInValSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psInValSelectionValue->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue_YES); +// +// // add name for new value +// mmXML::mmXMLNodeI* v_psNewParamName = v_psGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psNewParamNameName = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psNewParamNameName->SetText(L" Set new name for input value: "); +// // type +// mmXML::mmXMLNodeI* v_psNewParamNameType = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psNewParamNameType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psNewParamNameValue = v_psNewParamName->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psNewParamNameValue->SetText(L""); +// +// mmString v_sOutXML = v_psXMLDoc->SaveToXMLBuffer(); +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End CreateNewConstantInputDecisionUI")); +// +// return v_sOutXML; +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddSingleCalculationMethodIntoPattern( mmString p_sCalculationMethodParams, +// mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddSingleCalculationMethodIntoPattern")); +// +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // parse string +// v_psXMLDoc->ParseXMLBuffer(p_sCalculationMethodParams); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmImages::g_pComplexCalcXML_PatternDefinition_Node)->AddChild(mmImages::g_pComplexCalcXML_PatternCalcMethod_Node); +// // add name of CM +// mmXML::mmXMLNodeI* v_psXMLCCNewMethodName = v_psXMLCCNewMethod->AddChild(mmImages::g_pComplexCalcXML_PatternCalcMethodIDName_Node); +// v_psXMLCCNewMethodName->SetText(v_psRootNode->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// // adding input params node +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParams = v_psXMLCCNewMethod->AddChild(mmClouds::g_pAutoCalcXML_INParams_Node); +// +// // add CM input params +// std::vector v_vInputParams = v_psRootNode->GetChild(1)->GetChilds(); +// mmInt v_iIPCount = v_vInputParams.size(); +// for(mmInt v_iIP=1;v_iIP v_vOrigAttrParams = v_vInputParams[v_iIP]->GetAttributes(); +// +// if(v_vOrigAttrParams.size() > 0) +// { +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam = v_psXMLCCNewMethod_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Name = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLCCNewMethod_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLCCNewMethod_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Type = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Value = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam = v_psXMLCCNewMethod_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Name = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLCCNewMethod_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLCCNewMethod_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Type = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Value = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam = v_psXMLCCNewMethod_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Name = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLCCNewMethod_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLCCNewMethod_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Type = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Value = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam = v_psXMLCCNewMethod_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Name = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLCCNewMethod_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLCCNewMethod_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Type = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Value = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam = v_psXMLCCNewMethod_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Name = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLCCNewMethod_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLCCNewMethod_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Type = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_InParam_Value = v_psXMLCCNewMethod_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// }; +// }; +// +// // adding output params node +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParams = v_psXMLCCNewMethod->AddChild(mmClouds::g_pAutoCalcXML_OUTParams_Node); +// +// std::vector v_vOutputParams = v_psRootNode->GetChild(2)->GetChilds(); +// mmInt v_iOPCount = v_vOutputParams.size(); +// for(mmInt v_iOP=1;v_iOP v_vOrigAttrParams = v_vOutputParams[v_iOP]->GetAttributes(); +// +// if(v_vOrigAttrParams.size() > 0) +// { +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam = v_psXMLCCNewMethod_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Name = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLCCNewMethod_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Type = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Value = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam = v_psXMLCCNewMethod_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Name = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLCCNewMethod_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Type = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Value = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam = v_psXMLCCNewMethod_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Name = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLCCNewMethod_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Type = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Value = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam = v_psXMLCCNewMethod_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Name = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLCCNewMethod_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Type = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Value = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam = v_psXMLCCNewMethod_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Name = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLCCNewMethod_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Type = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLCCNewMethod_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLCCNewMethod_OutParam_Value = v_psXMLCCNewMethod_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLCCNewMethod_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// }; +// }; +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End AddSingleCalculationMethodIntoPattern")); +//} + +void mmImages::mmImagesComplexCalculationManagement::LoadComplexPatternsFromFile(mmString p_sCPFile) +{ + SendLogMessage(mmLog::debug,mmString(L"Start LoadComplexPatternsFromFile")); + + delete m_psXMLComplexPatternContainer; + m_psXMLComplexPatternContainer = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + + if(mmOperatingSystem::IsExistingFile(p_sCPFile)) + { + m_psXMLComplexPatternContainer->ParseXMLFile(p_sCPFile); + } + else + { + m_psXMLComplexPatternContainer->CreateXMLRootNode(mmImages::g_pComplexCalcXML_PatternContainer_Node); + }; + + SendLogMessage(mmLog::debug,mmString(L"End LoadComplexPatternsFromFile")); +} + +// PB ?? +//void mmImages::mmImagesComplexCalculationManagement::SaveComplexPatternsIntoFile(mmString p_sCPFile) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start SaveComplexPatternsIntoFile")); +// +// m_psXMLComplexPatternContainer->SaveToXMLFile(p_sCPFile); +// +// SendLogMessage(mmLog::debug,mmString(L"End SaveComplexPatternsIntoFile")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddComplexPatternIntoContainer(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddComplexPatternIntoContainer")); +// +// /* +// std::vector v_vPatternCMs = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()-> +// FindChild(mmClouds::g_pComplexCalcXML_PatternDefinition_Node)-> +// GetChilds(); +// +// if(v_vPatternCMs.size() > 0) +// { +// // check name of pattern; if this name exists, add extension _YYYYMMDDHHMMSS +// mmString v_sNewPatternName = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()-> +// FindChild(mmClouds::g_pComplexCalcXML_PatternName_Node)-> +// GetText(); +// std::vector v_vCCPatterns = m_psXMLComplexPatternContainer->GetXMLRootNode()->GetChilds(); +// mmInt v_iCCPCount = v_vCCPatterns.size(); +// for(mmInt v_iCCP=0;v_iCCPFindChild(mmClouds::g_pComplexCalcXML_PatternName_Node)->GetText().compare(v_sNewPatternName) == 0) +// { +// v_sNewPatternName += mmString(L" ") + +// mmStringUtilities::GetCurrentDateTimeString(); +// +// break; +// }; +// }; +// p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()->FindChild(mmClouds::g_pComplexCalcXML_PatternName_Node)->SetText(v_sNewPatternName); +// +// m_psXMLComplexPatternContainer->GetXMLRootNode()->AddChildWithStructure(p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()); +// +// SaveComplexPatternsIntoFile(m_sComplexPatternContainerXMLFile); +// +// if(m_psStateChangeReceiver != NULL) +// { +// m_psStateChangeReceiver->ListOfComplexCalculationPatternsUpdated(); +// }; +// }; +// */ +// +// m_psXMLComplexPatternContainer->GetXMLRootNode()->AddChildWithStructure(p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()); +// +// SaveComplexPatternsIntoFile(m_sComplexPatternContainerXMLFile); +// +// if(m_psStateChangeReceiver != NULL) +// { +// m_psStateChangeReceiver->ListOfComplexCalculationPatternsUpdated(); +// }; +// +// SendLogMessage(mmLog::debug,mmString(L"End AddComplexPatternIntoContainer")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::UpdateComplexPatternInContainer(mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start UpdateComplexPatternInContainer")); +// +// std::vector v_vPatternCMs = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()-> +// FindChild(mmImages::g_pComplexCalcXML_PatternDefinition_Node)-> +// GetChilds(); +// +// if(v_vPatternCMs.size() > 0) +// { +// // find pattern with given name +// mmString v_sNewPatternIDName = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()-> +// FindChild(mmImages::g_pComplexCalcXML_PatternIDName_Node)-> +// GetText(); +// std::vector v_vCCPatterns = m_psXMLComplexPatternContainer->GetXMLRootNode()->GetChilds(); +// mmInt v_iCCPCount = v_vCCPatterns.size(); +// for(mmInt v_iCCP=0;v_iCCPFindChild(mmImages::g_pComplexCalcXML_PatternIDName_Node)->GetText().compare(v_sNewPatternIDName) == 0) +// { +// v_vCCPatterns[v_iCCP]->RemoveAllChilds(); +// +// std::vector v_vCurrentPatternChilds = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->GetChilds(); +// mmInt v_iCCount = v_vCurrentPatternChilds.size(); +// for(mmInt v_iC=0;v_iCAddChildWithStructure(v_vCurrentPatternChilds[v_iC]); +// }; +// +// break; +// }; +// }; +// +// SaveComplexPatternsIntoFile(m_sComplexPatternContainerXMLFile); +// +// if(m_psStateChangeReceiver != NULL) +// { +// m_psStateChangeReceiver->ListOfComplexCalculationPatternsUpdated(); +// }; +// }; +// +// SendLogMessage(mmLog::debug,mmString(L"End UpdateComplexPatternInContainer")); +//} + +mmXML::mmXMLNodeI* mmImages::mmImagesComplexCalculationManagement::GetComplexCalculationPatternDefinition(mmString p_sCCPIDName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetComplexCalculationPatternDefinition")); + + std::vector v_vCCPatterns = m_psXMLComplexPatternContainer->GetXMLRootNode()-> + GetChilds(); + + mmInt v_iCCPCount = v_vCCPatterns.size(); + for(mmInt v_iCCP=0;v_iCCPFindChild(mmImages::g_pComplexCalcXML_PatternIDName_Node)->GetText().compare(p_sCCPIDName) == 0) + { + return v_vCCPatterns[v_iCCP]; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetComplexCalculationPatternDefinition")); + + return NULL; +} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddInternalWHILELoop(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalWHILELoop")); +// +// // define input-output params +// // create XML document which stores input automation options +// mmXML::mmXMLDocI* v_psINXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psINXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_INParams_Node); +// mmXML::mmXMLNodeI* v_psRootNode = v_psINXMLDoc->GetXMLRootNode(); +// // add while control variable param +// mmXML::mmXMLNodeI* v_psWHILEControlVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psWHILEControlVariableName = v_psWHILEControlVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psWHILEControlVariableName->SetText(L"Continue WHILE loop?"); +// // type +// mmXML::mmXMLNodeI* v_psWHILEControlVariableType = v_psWHILEControlVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psWHILEControlVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // value +// mmXML::mmXMLNodeI* v_psWHILEControlVariableValue = v_psWHILEControlVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psWHILEControlVariableValue->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES); +// +// mmString v_sInParams = v_psINXMLDoc->SaveToXMLBuffer(); +// delete v_psINXMLDoc; +// +// // create XML document which stores output automation options +// mmXML::mmXMLDocI* v_psOUTXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psOUTXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_OUTParams_Node); +// +// mmString v_sOutParams = v_psOUTXMLDoc->SaveToXMLBuffer(); +// delete v_psOUTXMLDoc; +// +// // user set values of params +// bool v_bNoParams = false; +// mmString v_sCMInOutParams = GetUIDefinitionForInternalAction( mmImages::g_pComplexCalcXML_Action_AddWhileLoop, +// v_sInParams, +// v_sOutParams, +// &v_bNoParams); +// +// mmString v_sSCMDef = v_sCMInOutParams; +// if(!v_bNoParams) +// { +// v_sSCMDef = m_psMainWindow->ShowModalDialog(v_sCMInOutParams,this); +// }; +// +// // update in/out params of pattern +// mmString v_sSCMInOutDef = UpdateInputOutputParameters(v_sSCMDef); +// +// // add internal action into calculation pattern +// AddInternalMethodIntoPattern(v_sSCMInOutDef, +// m_psXMLCurrentPatternDefinition); +// +// SendLogMessage(mmLog::debug,mmString(L"End AddInternalWHILELoop")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddInternalENDWHILELoop(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalENDWHILELoop")); +// +// // define input-output params +// // create XML document which stores input automation options +// mmXML::mmXMLDocI* v_psINXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psINXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_INParams_Node); +// +// mmString v_sInParams = v_psINXMLDoc->SaveToXMLBuffer(); +// delete v_psINXMLDoc; +// +// // create XML document which stores output automation options +// mmXML::mmXMLDocI* v_psOUTXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psOUTXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_OUTParams_Node); +// +// mmString v_sOutParams = v_psOUTXMLDoc->SaveToXMLBuffer(); +// delete v_psOUTXMLDoc; +// +// // user set values of params +// bool v_bNoParams = false; +// mmString v_sCMInOutParams = GetUIDefinitionForInternalAction(mmImages::g_pComplexCalcXML_Action_AddEndWhile, +// v_sInParams, +// v_sOutParams, +// &v_bNoParams); +// +// mmString v_sSCMDef = v_sCMInOutParams; +// if(!v_bNoParams) +// { +// v_sSCMDef = m_psMainWindow->ShowModalDialog(v_sCMInOutParams,this); +// }; +// +// // update in/out params of pattern +// mmString v_sSCMInOutDef = UpdateInputOutputParameters(v_sSCMDef); +// +// // add internal action into calculation pattern +// AddInternalMethodIntoPattern(v_sSCMInOutDef, +// m_psXMLCurrentPatternDefinition); +// +// SendLogMessage(mmLog::debug,mmString(L"End AddInternalENDWHILELoop")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddInternalCopyBinaryOutToInVariable(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalCopyBinaryOutToInVariable")); +// +// // define input-output params +// // create XML document which stores input automation options +// mmXML::mmXMLDocI* v_psINXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psINXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_INParams_Node); +// mmXML::mmXMLNodeI* v_psRootNode = v_psINXMLDoc->GetXMLRootNode(); +// // add selection of surce output variable +// mmXML::mmXMLNodeI* v_psSelSourceVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psSelSourceVariableName = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psSelSourceVariableName->SetText(L"Source Binary Output Variable: "); +// // type +// mmXML::mmXMLNodeI* v_psSelSourceVariableType = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psSelSourceVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // value +// mmXML::mmXMLNodeI* v_psSelSourceVariableValue = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psSelSourceVariableValue->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES); +// // add selection of destination input variable +// mmXML::mmXMLNodeI* v_psSelDestinationVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psSelDestinationVariableName = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psSelDestinationVariableName->SetText(L"Destination Binary Input Variable: "); +// // type +// mmXML::mmXMLNodeI* v_psSelDestinationVariableType = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psSelDestinationVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // value +// mmXML::mmXMLNodeI* v_psSelDestinationVariableValue = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psSelDestinationVariableValue->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES); +// +// mmString v_sInParams = v_psINXMLDoc->SaveToXMLBuffer(); +// delete v_psINXMLDoc; +// +// // create XML document which stores output automation options +// mmXML::mmXMLDocI* v_psOUTXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psOUTXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_OUTParams_Node); +// +// mmString v_sOutParams = v_psOUTXMLDoc->SaveToXMLBuffer(); +// delete v_psOUTXMLDoc; +// +// // user set values of params +// bool v_bNoParams = false; +// mmString v_sCMInOutParams = GetUIDefinitionForInternalAction( mmImages::g_pComplexCalcXML_Action_CopyBinaryOutputToInputValue, +// v_sInParams, +// v_sOutParams, +// &v_bNoParams); +// +// mmString v_sSCMDef = v_sCMInOutParams; +// if(!v_bNoParams) +// { +// v_sSCMDef = m_psMainWindow->ShowModalDialog(v_sCMInOutParams,this); +// }; +// +// // update in/out params of pattern +// mmString v_sSCMInOutDef = UpdateInputOutputParameters(v_sSCMDef); +// +// // add internal action into calculation pattern +// AddInternalMethodIntoPattern(v_sSCMInOutDef, +// m_psXMLCurrentPatternDefinition); +// +// SendLogMessage(mmLog::debug,mmString(L"End AddInternalCopyBinaryOutToInVariable")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddInternalCopyIntOutToInVariable(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalCopyIntOutToInVariable")); +// +// // define input-output params +// // create XML document which stores input automation options +// mmXML::mmXMLDocI* v_psINXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psINXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_INParams_Node); +// mmXML::mmXMLNodeI* v_psRootNode = v_psINXMLDoc->GetXMLRootNode(); +// // add selection of surce output variable +// mmXML::mmXMLNodeI* v_psSelSourceVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psSelSourceVariableName = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psSelSourceVariableName->SetText(L"Source Integer Output Variable: "); +// // type +// mmXML::mmXMLNodeI* v_psSelSourceVariableType = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psSelSourceVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // value +// mmXML::mmXMLNodeI* v_psSelSourceVariableValue = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psSelSourceVariableValue->SetText(L""); +// // add selection of destination input variable +// mmXML::mmXMLNodeI* v_psSelDestinationVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psSelDestinationVariableName = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psSelDestinationVariableName->SetText(L"Destination Integer Input Variable: "); +// // type +// mmXML::mmXMLNodeI* v_psSelDestinationVariableType = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psSelDestinationVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // value +// mmXML::mmXMLNodeI* v_psSelDestinationVariableValue = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psSelDestinationVariableValue->SetText(L""); +// +// mmString v_sInParams = v_psINXMLDoc->SaveToXMLBuffer(); +// delete v_psINXMLDoc; +// +// // create XML document which stores output automation options +// mmXML::mmXMLDocI* v_psOUTXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psOUTXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_OUTParams_Node); +// +// mmString v_sOutParams = v_psOUTXMLDoc->SaveToXMLBuffer(); +// delete v_psOUTXMLDoc; +// +// // user set values of params +// bool v_bNoParams = false; +// mmString v_sCMInOutParams = GetUIDefinitionForInternalAction(mmImages::g_pComplexCalcXML_Action_CopyIntOutputToInputValue, +// v_sInParams, +// v_sOutParams, +// &v_bNoParams); +// +// mmString v_sSCMDef = v_sCMInOutParams; +// if(!v_bNoParams) +// { +// v_sSCMDef = m_psMainWindow->ShowModalDialog(v_sCMInOutParams,this); +// }; +// +// // update in/out params of pattern +// mmString v_sSCMInOutDef = UpdateInputOutputParameters(v_sSCMDef); +// +// // add internal action into calculation pattern +// AddInternalMethodIntoPattern(v_sSCMInOutDef, +// m_psXMLCurrentPatternDefinition); +// +// SendLogMessage(mmLog::debug,mmString(L"End AddInternalCopyIntOutToInVariable")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddInternalCopyRealOutToInVariable(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalCopyRealOutToInVariable")); +// +// // define input-output params +// // create XML document which stores input automation options +// mmXML::mmXMLDocI* v_psINXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psINXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_INParams_Node); +// mmXML::mmXMLNodeI* v_psRootNode = v_psINXMLDoc->GetXMLRootNode(); +// // add selection of surce output variable +// mmXML::mmXMLNodeI* v_psSelSourceVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psSelSourceVariableName = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psSelSourceVariableName->SetText(L"Source Real Output Variable: "); +// // type +// mmXML::mmXMLNodeI* v_psSelSourceVariableType = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psSelSourceVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_RealValue); +// // value +// mmXML::mmXMLNodeI* v_psSelSourceVariableValue = v_psSelSourceVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psSelSourceVariableValue->SetText(L""); +// // add selection of destination input variable +// mmXML::mmXMLNodeI* v_psSelDestinationVariable = v_psRootNode->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // name +// mmXML::mmXMLNodeI* v_psSelDestinationVariableName = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// v_psSelDestinationVariableName->SetText(L"Destination Real Input Variable: "); +// // type +// mmXML::mmXMLNodeI* v_psSelDestinationVariableType = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// v_psSelDestinationVariableType->SetText(mmImages::g_pAutoCalcXML_Params_ParamType_RealValue); +// // value +// mmXML::mmXMLNodeI* v_psSelDestinationVariableValue = v_psSelDestinationVariable->AddChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psSelDestinationVariableValue->SetText(L""); +// +// mmString v_sInParams = v_psINXMLDoc->SaveToXMLBuffer(); +// delete v_psINXMLDoc; +// +// // create XML document which stores output automation options +// mmXML::mmXMLDocI* v_psOUTXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psOUTXMLDoc->CreateXMLRootNode(mmImages::g_pAutoCalcXML_OUTParams_Node); +// +// mmString v_sOutParams = v_psOUTXMLDoc->SaveToXMLBuffer(); +// delete v_psOUTXMLDoc; +// +// // user set values of params +// bool v_bNoParams = false; +// mmString v_sCMInOutParams = GetUIDefinitionForInternalAction(mmImages::g_pComplexCalcXML_Action_CopyRealOutputToInputValue, +// v_sInParams, +// v_sOutParams, +// &v_bNoParams); +// +// mmString v_sSCMDef = v_sCMInOutParams; +// if(!v_bNoParams) +// { +// v_sSCMDef = m_psMainWindow->ShowModalDialog(v_sCMInOutParams,this); +// }; +// +// // update in/out params of pattern +// mmString v_sSCMInOutDef = UpdateInputOutputParameters(v_sSCMDef); +// +// // add internal action into calculation pattern +// AddInternalMethodIntoPattern(v_sSCMInOutDef, +// m_psXMLCurrentPatternDefinition); +// +// SendLogMessage(mmLog::debug,mmString(L"End AddInternalCopyRealOutToInVariable")); +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::GetUIDefinitionForInternalAction( mmString p_sInternalActionName, +// mmString p_sIAInParams, +// mmString p_sIAOutParams, +// bool* p_pbNoParams) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetUIDefinitionForInternalAction")); +// +// *p_pbNoParams = false; +// +// // input params XML +// mmXML::mmXMLDocI* v_psXMLDoc_InputParams = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psXMLDoc_InputParams->ParseXMLBuffer(p_sIAInParams); +// mmXML::mmXMLNodeI* v_psRootNode_InputParams = v_psXMLDoc_InputParams->GetXMLRootNode(); +// std::vector v_vInputParams = v_psRootNode_InputParams->GetChilds(); +// +// // output params XML +// mmXML::mmXMLDocI* v_psXMLDoc_OutputParams = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// v_psXMLDoc_OutputParams->ParseXMLBuffer(p_sIAOutParams); +// mmXML::mmXMLNodeI* v_psRootNode_OutputParams = v_psXMLDoc_OutputParams->GetXMLRootNode(); +// std::vector v_vOutputParams = v_psRootNode_OutputParams->GetChilds(); +// +// // input values +// std::vector v_vAvailableInputValues = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmImages::g_pComplexCalcXML_PatternInputParams_Node)->GetChilds(); +// mmInt v_iIVCount = v_vAvailableInputValues.size(); +// +// // output values +// std::vector v_vAvailableOutputValues = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParams_Node)->GetChilds(); +// mmInt v_iOVCount = v_vAvailableOutputValues.size(); +// +// // create XML document which specifies new calculation pattern wizard +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(p_sInternalActionName); +// +// // add input params group node +// mmXML::mmXMLNodeI* v_psInParamsGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psInParamsGroupNodeName = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psInParamsGroupNodeName->SetText(L" Input Params: "); +// +// mmInt v_iIPCount = v_vInputParams.size(); +// for(mmInt v_iIP=0;v_iIPFindChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node)->GetText(); +// mmString v_sType = v_vInputParams[v_iIP]->FindChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node)->GetText(); +// mmString v_sInitValue = v_vInputParams[v_iIP]->FindChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node)->GetText(); +// +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudNames) == 0) +// { +// // add cloud names +// mmXML::mmXMLNodeI* v_psCloudCount = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psCloudCount->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psCloudCount->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psCloudCount->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sInitValue); +// // name +// mmXML::mmXMLNodeI* v_psCloudCountName = v_psCloudCount->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psCloudCountName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psCloudCountType = v_psCloudCount->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psCloudCountType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psCloudCountValue = v_psCloudCount->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psCloudCountValue->SetText(v_sInitValue); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // add binary decision +// mmXML::mmXMLNodeI* v_psBinaryDecision = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psBinaryDecision->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psBinaryDecision->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psBinaryDecision->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sInitValue); +// // name +// mmXML::mmXMLNodeI* v_psBinaryDecisionName = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psBinaryDecisionName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psBinaryDecisionType = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psBinaryDecisionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psBinaryDecisionRange = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psBinaryDecisionRangeStringList = v_psBinaryDecisionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iIV=0;v_iIVFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psBinaryDecisionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableInputValues[v_iIV]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iOV=0;v_iOVFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psBinaryDecisionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableOutputValues[v_iOV]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psBinaryDecisionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// // value +// mmXML::mmXMLNodeI* v_psBinaryDecisionValue = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psBinaryDecisionValue->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // add cloud name +// mmXML::mmXMLNodeI* v_psCloud = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psCloud->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psCloud->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psCloud->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sInitValue); +// // name +// mmXML::mmXMLNodeI* v_psCloudName = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psCloudName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psCloudType = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psCloudType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psCloudRange = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psCloudRangeStringList = v_psCloudRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iIV=0;v_iIVFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psCloudRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableInputValues[v_iIV]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iOV=0;v_iOVFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psCloudRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableOutputValues[v_iOV]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psCloudRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// // value +// mmXML::mmXMLNodeI* v_psCloudValue = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psCloudValue->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // add Data Layer name +// mmXML::mmXMLNodeI* v_psDataLayer = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psDataLayer->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psDataLayer->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psDataLayer->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sInitValue); +// // name +// mmXML::mmXMLNodeI* v_psDataLayerName = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psDataLayerName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psDataLayerType = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psDataLayerType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psDataLayerRange = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psDataLayerRangeStringList = v_psDataLayerRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iIV=0;v_iIVFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psDataLayerRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableInputValues[v_iIV]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iOV=0;v_iOVFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psDataLayerRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableOutputValues[v_iOV]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psDataLayerRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// // value +// mmXML::mmXMLNodeI* v_psDataLayerValue = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psDataLayerValue->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // add int value +// mmXML::mmXMLNodeI* v_psInteger = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psInteger->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psInteger->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psInteger->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sInitValue); +// // name +// mmXML::mmXMLNodeI* v_psIntegerName = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psIntegerName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psIntegerType = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psIntegerType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psIntegerRange = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psIntegerRangeStringList = v_psIntegerRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iIV=0;v_iIVFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psIntegerRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableInputValues[v_iIV]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iOV=0;v_iOVFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psIntegerRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableOutputValues[v_iOV]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psIntegerRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// // value +// mmXML::mmXMLNodeI* v_psIntegerValue = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psIntegerValue->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // add real value +// mmXML::mmXMLNodeI* v_psReal = v_psInParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psReal->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psReal->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psReal->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sInitValue); +// // name +// mmXML::mmXMLNodeI* v_psRealName = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRealName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psRealType = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psRealType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psRealValueRange = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psRealValueRangeStringList = v_psRealValueRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iIV=0;v_iIVFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psRealValueRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableInputValues[v_iIV]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iOV=0;v_iOVFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psRealValueRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableOutputValues[v_iOV]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psRealValueRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// // value +// mmXML::mmXMLNodeI* v_psRealValue = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psRealValue->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// }; +// }; +// +// // add output params group node +// mmXML::mmXMLNodeI* v_psOutParamsGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psOutParamsGroupNodeName = v_psOutParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psOutParamsGroupNodeName->SetText(L" Output Params: "); +// +// mmInt v_iOPCount = v_vOutputParams.size(); +// for(mmInt v_iOP=0;v_iOPFindChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node)->GetText(); +// mmString v_sType = v_vOutputParams[v_iOP]->FindChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node)->GetText(); +// mmString v_sValue = v_vOutputParams[v_iOP]->FindChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node)->GetText(); +// +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // add cloud name +// mmXML::mmXMLNodeI* v_psBinaryDecision = v_psOutParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psBinaryDecision->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psBinaryDecision->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psBinaryDecision->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sValue); +// // name +// mmXML::mmXMLNodeI* v_psBinaryDecisionName = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psBinaryDecisionName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psBinaryDecisionType = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psBinaryDecisionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psBinaryDecisionValue = v_psBinaryDecision->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psBinaryDecisionValue->SetText(L""); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // add binary decision +// mmXML::mmXMLNodeI* v_psCloud = v_psOutParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psCloud->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psCloud->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psCloud->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sValue); +// // name +// mmXML::mmXMLNodeI* v_psCloudName = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psCloudName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psCloudType = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psCloudType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psCloudValue = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psCloudValue->SetText(L""); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // add Data Layer name +// mmXML::mmXMLNodeI* v_psDataLayer = v_psOutParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psDataLayer->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psDataLayer->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psDataLayer->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sValue); +// // name +// mmXML::mmXMLNodeI* v_psDataLayerName = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psDataLayerName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psDataLayerType = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psDataLayerType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psDataLayerValue = v_psDataLayer->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psDataLayerValue->SetText(L""); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // add int value +// mmXML::mmXMLNodeI* v_psInteger = v_psOutParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psInteger->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psInteger->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psInteger->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sValue); +// // name +// mmXML::mmXMLNodeI* v_psIntegerName = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psIntegerName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psIntegerType = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psIntegerType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psIntegerValue = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psIntegerValue->SetText(L""); +// }; +// if(v_sType.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // add real value +// mmXML::mmXMLNodeI* v_psReal = v_psOutParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // add orig attributes +// v_psReal->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamName_Node,v_sName); +// v_psReal->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamType_Node,v_sType); +// v_psReal->AddAttribute(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node,v_sValue); +// // name +// mmXML::mmXMLNodeI* v_psRealName = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRealName->SetText(v_sName); +// // type +// mmXML::mmXMLNodeI* v_psRealType = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psRealType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // value +// mmXML::mmXMLNodeI* v_psRealValue = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psRealValue->SetText(L""); +// }; +// }; +// +// if( (v_iIPCount == 0) && (v_iOPCount == 0) ) +// { +// *p_pbNoParams = true; +// }; +// +// mmString v_sOutDialog = v_psXMLDoc->SaveToXMLBuffer(); +// +// delete v_psXMLDoc_InputParams; +// delete v_psXMLDoc_OutputParams; +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End GetUIDefinitionForInternalAction")); +// +// return v_sOutDialog; +//} + +// PB // +//mmString mmImages::mmImagesComplexCalculationManagement::GetUIDefinitionForMultiSelectValues(mmString p_sUIData) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalCreationOfSimplifiedCloudStructureIntoPattern")); +// +// // input values +// std::vector v_vAvailableInputValues = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmImages::g_pComplexCalcXML_PatternInputParams_Node)->GetChilds(); +// mmInt v_iIVCount = v_vAvailableInputValues.size(); +// +// // output values +// std::vector v_vAvailableOutputValues = m_psXMLCurrentPatternDefinition->GetXMLRootNode()->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParams_Node)->GetChilds(); +// mmInt v_iOVCount = v_vAvailableOutputValues.size(); +// +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // parse string +// v_psXMLDoc->ParseXMLBuffer(p_sUIData); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// // in params values +// std::vector v_vInParams = v_psRootNode->GetChild(1)->GetChilds(); +// mmInt v_iInPCount = v_vInParams.size(); +// for(mmInt v_iInP=1;v_iInPGetAttributeValue(mmImages::g_pAutoCalcXML_Params_ParamType_Node); +// +// if(v_sInParamType.compare(mmImages::g_pAutoCalcXML_Params_ParamType_ImagesNames) == 0) +// { +// mmString v_sMultiCloudSelectionValue = v_vInParams[v_iInP]-> +// FindChild(mmUI::g_pUIXML_EL_DEF_Value)-> +// GetText(); +// +// // if not all selected +// if(v_sMultiCloudSelectionValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudCount_All) != 0) +// { +// // create UI for cloud names +// mmInt v_iCloudToSelectCount = mmStringUtilities::StringToMMInt(v_sMultiCloudSelectionValue); +// +// // create XML document which specifies multi cloud selection +// mmXML::mmXMLDocI* v_psXMLDocUI = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDocUI = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDocUI->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNodeUI = v_psXMLDocUI->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeUIName = v_psRootNodeUI->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeUIName->SetText(L" Select clouds: "); +// +// // add cloud selection group node +// mmXML::mmXMLNodeI* v_psClSelGroupNode = v_psRootNodeUI->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psClSelGroupNodeName = v_psClSelGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psClSelGroupNodeName->SetText(L" Clouds: "); +// +// for(mmInt v_iC=0;v_iCAddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psCloudName = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psCloudName->SetText(mmString(L" Cloud ") + +// mmStringUtilities::MMIntToString(v_iC+1) + +// mmString(L": ")); +// // type +// mmXML::mmXMLNodeI* v_psCloudType = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psCloudType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psCloudRange = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psCloudRangeStringList = v_psCloudRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// for(mmInt v_iIV=0;v_iIVFindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psCloudRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableInputValues[v_iIV]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// }; +// }; +// for(mmInt v_iOV=0;v_iOVFindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamType_Node)->GetText().compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psCloudRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vAvailableOutputValues[v_iOV]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()); +// }; +// }; +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psCloudRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// // value +// mmXML::mmXMLNodeI* v_psCloudValue = v_psCloud->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psCloudValue->SetText(mmClouds::g_pComplexCalcXML_PatternInputParamUserSpecified); +// }; +// +// // show dialog +// mmString v_sInDialog = v_psXMLDocUI->SaveToXMLBuffer(); +// delete v_psXMLDocUI; +// +// mmString v_sOutDialog = m_psMainWindow->ShowModalDialog(v_sInDialog); +// +// // parse result +// mmXML::mmXMLDocI* v_psXMLDocUIRes = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDocUIRes = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // parse string +// v_psXMLDocUIRes->ParseXMLBuffer(v_sOutDialog); +// mmXML::mmXMLNodeI* v_psRootNodeUIRes = v_psXMLDocUIRes->GetXMLRootNode(); +// +// std::vector v_vResClouds = v_psRootNodeUIRes->GetChild(1)->GetChilds(); +// for(mmInt v_iC=0;v_iCFindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText(); +// +// v_sMultiCloudSelectionValue += v_sCloudNameToAdd; +// }; +// +// v_vInParams[v_iInP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->SetText(v_sMultiCloudSelectionValue); +// delete v_psXMLDocUIRes; +// }; +// }; +// }; +// +// mmString v_sOutRes = v_psXMLDoc->SaveToXMLBuffer(); +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End GetUIDefinitionForInternalAction")); +// +// return v_sOutRes; +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::AddInternalMethodIntoPattern( mmString p_sInOutParams, +// mmXML::mmXMLDocI* p_psXMLComplexCalculationPatternDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start AddInternalCreationOfSimplifiedCloudStructureIntoPattern")); +// +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // parse string +// v_psXMLDoc->ParseXMLBuffer(p_sInOutParams); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction = p_psXMLComplexCalculationPatternDefinition->GetXMLRootNode()-> +// FindChild(mmImages::g_pComplexCalcXML_PatternDefinition_Node)-> +// AddChild(mmImages::g_pComplexCalcXML_PatternInternalAction_Node); +// // add name of IA +// mmXML::mmXMLNodeI* v_psXMLNewInternalActionName = v_psXMLNewInternalAction->AddChild(mmImages::g_pComplexCalcXML_PatternInternalActionName_Node); +// +// v_psXMLNewInternalActionName->SetText(v_psRootNode->FindChild(mmUI::g_pUIXML_EL_DEF_Name)->GetText()); +// +// // adding input params node +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParams = v_psXMLNewInternalAction->AddChild(mmImages::g_pAutoCalcXML_INParams_Node); +// +// // add IA input params +// std::vector v_vInputParams = v_psRootNode->GetChild(1)->GetChilds(); +// mmInt v_iIPCount = v_vInputParams.size(); +// for(mmInt v_iIP=1;v_iIP v_vOrigAttrParams = v_vInputParams[v_iIP]->GetAttributes(); +// +// if(v_vOrigAttrParams.size() > 0) +// { +// if(v_vOrigAttrParams[1].sValue.compare(mmImages::g_pAutoCalcXML_Params_ParamType_ImagesNames) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam = v_psXMLNewInternalAction_InParams->AddChild(mmImages::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Name = v_psXMLNewInternalAction_InParam->AddChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLNewInternalAction_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLNewInternalAction_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Type = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudNames); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Value = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam = v_psXMLNewInternalAction_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Name = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLNewInternalAction_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLNewInternalAction_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Type = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Value = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam = v_psXMLNewInternalAction_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Name = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLNewInternalAction_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLNewInternalAction_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Type = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Value = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam = v_psXMLNewInternalAction_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Name = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLNewInternalAction_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLNewInternalAction_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Type = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Value = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam = v_psXMLNewInternalAction_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Name = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLNewInternalAction_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLNewInternalAction_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Type = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Value = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // adding input param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam = v_psXMLNewInternalAction_InParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Name = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// //v_psXMLNewInternalAction_InParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// v_psXMLNewInternalAction_InParam_Name->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Type = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_InParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_InParam_Value = v_psXMLNewInternalAction_InParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_InParam_Value->SetText(v_vInputParams[v_iIP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// }; +// }; +// +// // adding output params node +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParams = v_psXMLNewInternalAction->AddChild(mmClouds::g_pAutoCalcXML_OUTParams_Node); +// +// std::vector v_vOutputParams = v_psRootNode->GetChild(2)->GetChilds(); +// mmInt v_iOPCount = v_vOutputParams.size(); +// for(mmInt v_iOP=1;v_iOP v_vOrigAttrParams = v_vOutputParams[v_iOP]->GetAttributes(); +// +// if(v_vOrigAttrParams.size() > 0) +// { +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam = v_psXMLNewInternalAction_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Name = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLNewInternalAction_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Type = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Value = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam = v_psXMLNewInternalAction_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Name = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLNewInternalAction_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Type = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Value = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam = v_psXMLNewInternalAction_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Name = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLNewInternalAction_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Type = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Value = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam = v_psXMLNewInternalAction_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Name = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLNewInternalAction_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Type = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Value = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// if(v_vOrigAttrParams[1].sValue.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // adding output param +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam = v_psXMLNewInternalAction_OutParams->AddChild(mmClouds::g_pAutoCalcXML_Params_Param_Node); +// // add name +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Name = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamName_Node); +// v_psXMLNewInternalAction_OutParam_Name->SetText(v_vOrigAttrParams[0].sValue); +// // add type +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Type = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamType_Node); +// v_psXMLNewInternalAction_OutParam_Type->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue); +// // add value +// mmXML::mmXMLNodeI* v_psXMLNewInternalAction_OutParam_Value = v_psXMLNewInternalAction_OutParam->AddChild(mmClouds::g_pAutoCalcXML_Params_ParamValue_Node); +// v_psXMLNewInternalAction_OutParam_Value->SetText(v_vOutputParams[v_iOP]->FindChild(mmUI::g_pUIXML_EL_DEF_Value)->GetText()); +// }; +// }; +// }; +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End AddInternalCreationOfSimplifiedCloudStructureIntoPattern")); +//} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::InitializeCurrentComplexCalculationPatternExecution(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start InitializeCurrentComplexCalculationPatternExecution")); +// +//// PB // +//// // set UI for user input values +//// GetComplexCalculationPatternInputParamsFromUI(m_psXMLCalculatedPatternDefinition); +// +// SendLogMessage(mmLog::debug,mmString(L"End InitializeCurrentComplexCalculationPatternExecution")); +//} + +bool mmImages::mmImagesComplexCalculationManagement::ManageCurrentComplexCalculationPatternExecution(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ManageCurrentComplexCalculationPatternExecution")); + + bool v_bIsFinishedCalculation = true; + + // check if m_psCoPCalculationManagement object is calculating + bool v_bIsCalculating = m_psImageCalculationManagement->IsCalculating(); + + // check if there is a next simple calc method + if(v_bIsCalculating) + { + v_bIsFinishedCalculation = false; + } + else + { + std::vector v_vCalcMethods = m_psXMLCalculatedPatternDefinition-> + FindChild(mmImages::g_pComplexCalcXML_PatternDefinition_Node)-> + GetChilds(); + + // intialize output params + if(m_iCurrentComplexCalculationItem > -1) + { +// PB // + UpdateOutputParamsOfSimpleCalculationMethod( m_psXMLCalculatedPatternDefinition, + m_iCurrentComplexCalculationItem); + + delete m_psCurrentCalculationMethod; + m_psCurrentCalculationMethod = NULL; + }; + + // check next calculation method number + m_iCurrentComplexCalculationItem++; + if(static_cast(v_vCalcMethods.size()) > m_iCurrentComplexCalculationItem) + { + // check if it is calculation method or internal action + mmString v_sOperationType = v_vCalcMethods[m_iCurrentComplexCalculationItem]->GetName(); + + // internal action + if(v_sOperationType.compare(mmImages::g_pComplexCalcXML_PatternInternalAction_Node) == 0) + { + mmString v_sInternalActionName = v_vCalcMethods[m_iCurrentComplexCalculationItem]->FindChild(mmImages::g_pComplexCalcXML_PatternInternalActionName_Node)->GetText(); + +// PB // +// if( (v_sInternalActionName.compare(mmImages::g_pComplexCalcXML_Action_CopyBinaryOutputToInputValue) == 0) || +// (v_sInternalActionName.compare(mmImages::g_pComplexCalcXML_Action_CopyIntOutputToInputValue) == 0) || +// (v_sInternalActionName.compare(mmImages::g_pComplexCalcXML_Action_CopyRealOutputToInputValue) == 0) ) +// { +// // initialize input params +// mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams v_sCAP; +// v_sCAP = InitializeParamsOfSimpleCalculationMethod( m_psXMLCalculatedPatternDefinition, +// m_iCurrentComplexCalculationItem); +// +// // copy values +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// v_psXMLDoc->ParseXMLBuffer(v_sCAP.sInParams); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// mmString v_sSourceValue = v_psRootNode-> +// GetChild(0)-> +// FindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)-> +// GetText(); +// mmString v_sDestName = v_psRootNode-> +// GetChild(1)-> +// FindChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node)-> +// GetText(); +// +// mmString v_sLogText = mmString(L"CopyValue ") + +// v_sDestName + +// mmString(L"=") + +// v_sSourceValue; +// SendLogMessage(mmLog::user,v_sLogText); +// +// SetValueOfParameter(m_psXMLCalculatedPatternDefinition,v_sDestName,v_sSourceValue); +// }; + +// PB // +// if(v_sInternalActionName.compare(mmImages::g_pComplexCalcXML_Action_AddEndWhile) == 0) +// { +// // search for while +// mmInt v_iStartWhileIndex = -1; +// mmInt v_iWhileAndEndWhileCount = 0; +// mmInt v_iCMSize = v_vCalcMethods.size(); +// for(mmInt v_iCM=m_iCurrentComplexCalculationItem-1;v_iCM>=0;v_iCM--) +// { +// if(v_vCalcMethods[v_iCM]->GetName().compare(mmImages::g_pComplexCalcXML_PatternInternalAction_Node) == 0) +// { +// mmString v_sIAName = v_vCalcMethods[v_iCM]-> +// FindChild(mmImages::g_pComplexCalcXML_PatternInternalActionName_Node)-> +// GetText(); +// +// if(v_sIAName.compare(mmImages::g_pComplexCalcXML_Action_AddEndWhile) == 0) +// { +// v_iWhileAndEndWhileCount++; +// }; +// if(v_sIAName.compare(mmImages::g_pComplexCalcXML_Action_AddWhileLoop) == 0) +// { +// if(v_iWhileAndEndWhileCount > 0) +// { +// v_iWhileAndEndWhileCount--; +// } +// else +// { +// v_iStartWhileIndex = v_iCM-1; +// break; +// }; +// }; +// }; +// }; +// m_iCurrentComplexCalculationItem = v_iStartWhileIndex; +// }; + +// PB // +// if(v_sInternalActionName.compare(mmImages::g_pComplexCalcXML_Action_AddWhileLoop) == 0) +// { +// // initialize input params +// mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams v_sCAP; +// v_sCAP = InitializeParamsOfSimpleCalculationMethod( m_psXMLCalculatedPatternDefinition, +// m_iCurrentComplexCalculationItem); +// +// // while condition +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// v_psXMLDoc->ParseXMLBuffer(v_sCAP.sInParams); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// bool v_bContinueWhile = false; +// if(v_psRootNode-> +// GetChild(0)-> +// FindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)-> +// GetText().compare(mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES) == 0) +// { +// v_bContinueWhile = true; +// }; +// +// if(!v_bContinueWhile) +// { +// // search for end while +// mmInt v_iEndWhileNextIndex = -1; +// mmInt v_iWhileAndEndWhileCount = 0; +// mmInt v_iCMSize = v_vCalcMethods.size(); +// for(mmInt v_iCM=m_iCurrentComplexCalculationItem+1;v_iCMGetName().compare(mmImages::g_pComplexCalcXML_PatternInternalAction_Node) == 0) +// { +// mmString v_sIAName = v_vCalcMethods[v_iCM]-> +// FindChild(mmImages::g_pComplexCalcXML_PatternInternalActionName_Node)-> +// GetText(); +// +// if(v_sIAName.compare(mmImages::g_pComplexCalcXML_Action_AddWhileLoop) == 0) +// { +// v_iWhileAndEndWhileCount++; +// }; +// if(v_sIAName.compare(mmImages::g_pComplexCalcXML_Action_AddEndWhile) == 0) +// { +// if(v_iWhileAndEndWhileCount > 0) +// { +// v_iWhileAndEndWhileCount--; +// } +// else +// { +// v_iEndWhileNextIndex = v_iCM; +// +// break; +// }; +// }; +// }; +// }; +// +// m_iCurrentComplexCalculationItem = v_iEndWhileNextIndex; +// }; +// }; + }; + + // simple calculation method + if(v_sOperationType.compare(mmImages::g_pComplexCalcXML_PatternCalcMethod_Node) == 0) + { + //mmOperatingSystem::StopThread(50); + m_psCurrentCalculationMethod = m_psImageCalculationMethodContainer->InitializeImagesCalculationMethod( v_vCalcMethods[m_iCurrentComplexCalculationItem]-> + FindChild(mmImages::g_pComplexCalcXML_PatternCalcMethodIDName_Node)-> + GetText()); + + // initialize input params + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams v_sCAP; + v_sCAP = InitializeParamsOfSimpleCalculationMethod( m_psXMLCalculatedPatternDefinition, + m_iCurrentComplexCalculationItem); + + // start calculation + m_psImageCalculationManagement->CalculateImages( m_psCurrentCalculationMethod, + m_sCurrentComplexCalculation.psImageStructure, + &v_sCAP); + }; + + v_bIsFinishedCalculation = false; + }; + }; + + // clear calculation members + if(v_bIsFinishedCalculation) + { + m_psXMLCalculatedPatternDefinition = NULL; + }; + + SendLogMessage(mmLog::debug,mmString(L"End ManageCurrentComplexCalculationPatternExecution")); + + return v_bIsFinishedCalculation; +} + +// PB // +//void mmImages::mmImagesComplexCalculationManagement::GetComplexCalculationPatternInputParamsFromUI(mmXML::mmXMLNodeI* p_psComplexCalculationDefinition) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetComplexCalculationPatternInputParamsFromUI")); +// +// mmInt v_iValuesToSetCount = 0; +// +// // create XML document which specifies calculation pattern input params UI dialog +// mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); +// //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); +// +// // add dialog root node +// v_psXMLDoc->CreateXMLRootNode(mmUI::g_pUIXML_EL_UserDialog); +// mmXML::mmXMLNodeI* v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// // add visible name for dialog +// mmXML::mmXMLNodeI* v_psRootNodeName = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRootNodeName->SetText(p_psComplexCalculationDefinition->FindChild(mmClouds::g_pComplexCalcXML_PatternName_Node)->GetText() + +// mmString(L" - Input Paramters Definition")); +// +// // add global params group node +// mmXML::mmXMLNodeI* v_psInputParamsGroupNode = v_psRootNode->AddChild(mmUI::g_pUIXML_EL_Group); +// // add visible name for group node +// mmXML::mmXMLNodeI* v_psInputParamsGroupNodeName = v_psInputParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psInputParamsGroupNodeName->SetText(L" Params: "); +// +// std::vector v_vInParams = p_psComplexCalculationDefinition->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParams_Node)->GetChilds(); +// mmInt v_iIPCount = v_vInParams.size(); +// for(mmInt v_iIP=0;v_iIP v_sAttributes = v_vInParams[v_iIP]->GetAttributes(); +// mmXML::mmXMLNodeI* v_psXMLModifiedValueNode = v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamValueModifiedNodeName_Node); +// +// if( (v_sAttributes.size() == 0) && +// (v_psXMLModifiedValueNode == NULL) ) +// { +// mmString v_sNodeTypeStr = v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamType_Node)->GetText(); +// +// if(v_sNodeTypeStr.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_CloudName) == 0) +// { +// // add cloud selection +// mmXML::mmXMLNodeI* v_psCloudSelection = v_psInputParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psCloudSelectionName = v_psCloudSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psCloudSelectionName->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// // type +// mmXML::mmXMLNodeI* v_psCloudSelectionType = v_psCloudSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psCloudSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psCloudSelectionValueRange = v_psCloudSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psCloudSelectionValueRangeStringList = v_psCloudSelectionValueRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// mmInt v_iCCount = m_sCurrentComplexCalculation.psCloudStructure->GetCloudsCount(); +// for(mmInt v_iC=0;v_iCAddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(m_sCurrentComplexCalculation.psCloudStructure->GetDirectionalCloudOfPointsName(v_iC)); +// }; +// // value +// mmXML::mmXMLNodeI* v_psCloudSelectionValue = v_psCloudSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psCloudSelectionValue->SetText(mmUI::g_pUIXML_Value_SELECT); +// }; +// if(v_sNodeTypeStr.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_DataLayerName) == 0) +// { +// // add groups data layer selection +// mmXML::mmXMLNodeI* v_psDLSelection = v_psInputParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psDLSelectionName = v_psDLSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psDLSelectionName->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// // type +// mmXML::mmXMLNodeI* v_psDLSelectionType = v_psDLSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psDLSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psDLSelectionValueRange = v_psDLSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psDLSelectionValueRangeStringList = v_psDLSelectionValueRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// std::vector v_vDLInfo = m_sCurrentComplexCalculation.psCloudStructure->GetDataLayersInfo(); +// mmInt v_iDLCount = v_vDLInfo.size(); +// for(mmInt v_iDL=0;v_iDLAddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(v_vDLInfo[v_iDL].sName); +// }; +// // value +// mmXML::mmXMLNodeI* v_psDLSelectionValue = v_psDLSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psDLSelectionValue->SetText(mmUI::g_pUIXML_Value_SELECT); +// }; +// if(v_sNodeTypeStr.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_RealValue) == 0) +// { +// // add real value input +// mmXML::mmXMLNodeI* v_psReal = v_psInputParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psRealName = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psRealName->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// // type +// mmXML::mmXMLNodeI* v_psRealType = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psRealType->SetText(mmUI::g_pUIXML_EL_DEF_Type_Real); +// // value +// mmXML::mmXMLNodeI* v_psRealValue = v_psReal->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psRealValue->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node)->GetText()); +// }; +// if(v_sNodeTypeStr.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_IntegerValue) == 0) +// { +// // add integer value input +// mmXML::mmXMLNodeI* v_psInteger = v_psInputParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psIntegerName = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psIntegerName->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// // type +// mmXML::mmXMLNodeI* v_psIntegerType = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psIntegerType->SetText(mmUI::g_pUIXML_EL_DEF_Type_Int); +// // value +// mmXML::mmXMLNodeI* v_psIntegerValue = v_psInteger->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psIntegerValue->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node)->GetText()); +// }; +// if(v_sNodeTypeStr.compare(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue) == 0) +// { +// // add binary decision input value selection +// mmXML::mmXMLNodeI* v_psBoolSelection = v_psInputParamsGroupNode->AddChild(mmUI::g_pUIXML_EL_SingleValue); +// // name +// mmXML::mmXMLNodeI* v_psBoolSelectionName = v_psBoolSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Name); +// v_psBoolSelectionName->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()); +// // type +// mmXML::mmXMLNodeI* v_psBoolSelectionType = v_psBoolSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Type); +// v_psBoolSelectionType->SetText(mmUI::g_pUIXML_EL_DEF_Type_String); +// // values range +// mmXML::mmXMLNodeI* v_psBoolSelectionRange = v_psBoolSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Range); +// mmXML::mmXMLNodeI* v_psBoolSelectionRangeStringList = v_psBoolSelectionRange->AddChild(mmUI::g_pUIXML_EL_DEF_StringList); +// mmXML::mmXMLNodeI* v_psUIStringListElement = v_psBoolSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue_YES); +// v_psUIStringListElement = v_psBoolSelectionRangeStringList->AddChild(mmUI::g_pUIXML_EL_DEF_StringListElement); +// v_psUIStringListElement->SetText(mmClouds::g_pAutoCalcXML_Params_ParamType_BoolValue_NO); +// // value +// mmXML::mmXMLNodeI* v_psBoolSelectionValue = v_psBoolSelection->AddChild(mmUI::g_pUIXML_EL_DEF_Value); +// v_psBoolSelectionValue->SetText(v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node)->GetText()); +// }; +// +// v_iValuesToSetCount++; +// }; +// }; +// +// mmString v_sOutDefinition = v_psXMLDoc->SaveToXMLBuffer(); +// +// if(v_iValuesToSetCount > 0) +// { +// // show dialog +// mmString v_sUserInput = m_psMainWindow->ShowModalDialog(v_sOutDefinition,this); +// +// // parse output +// v_psXMLDoc->ParseXMLBuffer(v_sUserInput); +// v_psRootNode = v_psXMLDoc->GetXMLRootNode(); +// +// v_iValuesToSetCount = 0; +// for(mmInt v_iIP=0;v_iIP v_sAttributes = v_vInParams[v_iIP]->GetAttributes(); +// mmXML::mmXMLNodeI* v_psXMLModifiedValueNode = v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamValueModifiedNodeName_Node); +// +// if( (v_sAttributes.size() == 0) && +// (v_psXMLModifiedValueNode == NULL) ) +// { +// v_vInParams[v_iIP]->FindChild(mmClouds::g_pComplexCalcXML_PatternInputParamValue_Node)->SetText( v_psRootNode-> +// GetChild(1)-> +// GetChild(1+v_iValuesToSetCount)-> +// FindChild(mmUI::g_pUIXML_EL_DEF_Value)-> +// GetText()); +// +// v_iValuesToSetCount++; +// }; +// }; +// }; +// +// delete v_psXMLDoc; +// +// SendLogMessage(mmLog::debug,mmString(L"End GetComplexCalculationPatternInputParamsFromUI")); +//} + +mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams mmImages::mmImagesComplexCalculationManagement::InitializeParamsOfSimpleCalculationMethod(mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmInt p_iCalculationMethodToInitializeID) +{ + SendLogMessage(mmLog::debug,mmString(L"Start InitializeParamsOfSimpleCalculationMethod")); + + mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams v_sCAP; + + mmXML::mmXMLNodeI* v_psXMLCalcMethod = p_psXMLCalcPatternDefinition-> + FindChild(mmImages::g_pComplexCalcXML_PatternDefinition_Node)-> + GetChild(p_iCalculationMethodToInitializeID); + + mmXML::mmXMLNodeI* v_psXMLCalcMethod_InParams = v_psXMLCalcMethod->FindChild(mmImages::g_pAutoCalcXML_INParams_Node); + std::vector v_vCMInParams = v_psXMLCalcMethod_InParams->GetChilds(); + mmInt v_iCMIPCount = v_vCMInParams.size(); + for(mmInt v_iCMIP=0;v_iCMIPFindChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node)->GetText(); + + mmString v_sParamType = v_vCMInParams[v_iCMIP]->FindChild(mmImages::g_pAutoCalcXML_Params_ParamType_Node)->GetText(); + + if(v_sParamType.compare(mmImages::g_pAutoCalcXML_Params_ParamType_ImagesNames) == 0) + { + if(v_sName.compare(mmImages::g_pAutoCalcXML_Params_ParamType_ImageCount_All) != 0) + { + std::vector v_vClNames = mmStringUtilities::MMStringToVectorOfMMString(v_sName); + mmInt v_iCCount = mmStringUtilities::StringToMMInt(v_vClNames[0]); + v_sValue = v_vClNames[0]; + for(mmInt v_iC=0;v_iCFindChild(mmImages::g_pAutoCalcXML_Params_ParamName_Node)->GetText()); + }; + + v_vCMInParams[v_iCMIP]->FindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)->SetText(v_sValue); + + SendLogMessage(mmLog::user,mmString(L"InParam Name=") + + v_sName + + mmString(L" Value=") + + v_sValue); + }; + + mmXML::mmXMLDocI* v_psINXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psINXMLDoc->CopyXMLRootNodeStructure(v_psXMLCalcMethod_InParams); + mmString v_sInParams = v_psINXMLDoc->SaveToXMLBuffer(); + mmInt v_iStrSize = v_sInParams.copy(v_sCAP.sInParams,INOUT_PARAMS_SIZE,0); + v_sCAP.sInParams[v_iStrSize] = 0; + delete v_psINXMLDoc; + + mmXML::mmXMLNodeI* v_psXMLCalcMethod_OutParams = v_psXMLCalcMethod->FindChild(mmImages::g_pAutoCalcXML_OUTParams_Node); + //std::vector v_vCMOutParams = v_psXMLCalcMethod_OutParams->GetChilds(); + //mmInt v_iCMOPCount = v_vCMOutParams.size(); + + mmXML::mmXMLDocI* v_psOUTXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psOUTXMLDoc->CopyXMLRootNodeStructure(v_psXMLCalcMethod_OutParams); + mmString v_sOutParams = v_psOUTXMLDoc->SaveToXMLBuffer(); + v_iStrSize = v_sOutParams.copy(v_sCAP.sOutParams,INOUT_PARAMS_SIZE,0); + v_sCAP.sOutParams[v_iStrSize] = 0; + delete v_psOUTXMLDoc; + + SendLogMessage(mmLog::debug,mmString(L"End InitializeParamsOfSimpleCalculationMethod")); + + return v_sCAP; +} + +// PB // +void mmImages::mmImagesComplexCalculationManagement::UpdateOutputParamsOfSimpleCalculationMethod( mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmInt p_iCalculationMethodToUpdateID) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UpdateOutputParamsOfSimpleCalculationMethod")); + + if(m_psCurrentCalculationMethod != NULL) + { + mmImages::mmImagesCalculationMethodI::sCalculationMethodParams v_sCMP = m_psCurrentCalculationMethod->GetCalculationMethodInfo(); + mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + //mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(NULL); + v_psXMLDoc->ParseXMLBuffer(v_sCMP.sAutoParams.sOutParams); + std::vector v_vCurrentCMOutParams = v_psXMLDoc->GetXMLRootNode()->GetChilds(); + + mmXML::mmXMLNodeI* v_psXMLCalcMethod = p_psXMLCalcPatternDefinition-> + FindChild(mmImages::g_pComplexCalcXML_PatternDefinition_Node)-> + GetChild(p_iCalculationMethodToUpdateID); + + mmXML::mmXMLNodeI* v_psXMLCalcMethod_OutParams = v_psXMLCalcMethod->FindChild(mmImages::g_pAutoCalcXML_OUTParams_Node); + std::vector v_vCMOutParams = v_psXMLCalcMethod_OutParams->GetChilds(); + mmInt v_iCMOPCount = v_vCMOutParams.size(); + for(mmInt v_iCMOP=0;v_iCMOPFindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)->GetText(), + v_vCurrentCMOutParams[v_iCMOP]->FindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)->GetText()); + + mmString v_sName = v_vCMOutParams[v_iCMOP]->FindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)->GetText(); + mmString v_sValue = v_vCurrentCMOutParams[v_iCMOP]->FindChild(mmImages::g_pAutoCalcXML_Params_ParamValue_Node)->GetText(); + + SendLogMessage(mmLog::user,mmString(L"OutParam Name=") + + v_sName + + mmString(L" Value=") + + v_sValue); + }; + + delete v_psXMLDoc; + }; + + SendLogMessage(mmLog::debug,mmString(L"End UpdateOutputParamsOfSimpleCalculationMethod")); +} + +mmString mmImages::mmImagesComplexCalculationManagement::GetValueOfParameter(mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmString p_sParamName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetValueOfParameter")); + + mmString v_sOutValue; + + mmXML::mmXMLNodeI* v_psXMLCalcPattern_InParams = p_psXMLCalcPatternDefinition->FindChild(mmImages::g_pComplexCalcXML_PatternInputParams_Node); + std::vector v_vCPInParams = v_psXMLCalcPattern_InParams->GetChilds(); + mmInt v_iCPIPCount = v_vCPInParams.size(); + for(mmInt v_iCMIP=0;v_iCMIPFindChild(mmImages::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()) == 0) + { + mmXML::mmXMLNodeI* v_psXMLCalcPattern_InParam_ModifiedNode = + v_vCPInParams[v_iCMIP]->FindChild(mmImages::g_pComplexCalcXML_PatternInputParamValueModifiedNodeName_Node); + + if(v_psXMLCalcPattern_InParam_ModifiedNode == NULL) + { + v_sOutValue = v_vCPInParams[v_iCMIP]->FindChild(mmImages::g_pComplexCalcXML_PatternInputParamValue_Node)->GetText(); + } + else + { + mmString v_sModifierValue = GetValueOfParameter(p_psXMLCalcPatternDefinition,v_psXMLCalcPattern_InParam_ModifiedNode->GetText()); + + std::vector v_vAttributes = v_vCPInParams[v_iCMIP]->GetAttributes(); + + if(v_vAttributes.size() == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_vCPInParams[v_iCMIP]->FindChild(mmImages::g_pComplexCalcXML_PatternInputParamValue_Node)->GetText()) * + mmStringUtilities::StringToMMReal(v_sModifierValue)); + } + else + { + v_sOutValue = GetValueOfParameter(p_psXMLCalcPatternDefinition,v_psXMLCalcPattern_InParam_ModifiedNode->GetText()); + }; + }; + + break; + }; + }; + + if(v_sOutValue.size() == 0) + { + mmXML::mmXMLNodeI* v_psXMLCalcPattern_OutParams = p_psXMLCalcPatternDefinition->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParams_Node); + std::vector v_vCPOutParams = v_psXMLCalcPattern_OutParams->GetChilds(); + mmInt v_iCPOPCount = v_vCPOutParams.size(); + for(mmInt v_iCMOP=0;v_iCMOPFindChild(mmImages::g_pComplexCalcXML_PatternOutputParamName_Node)->GetText()) == 0) + { + mmXML::mmXMLNodeI* v_psXMLCalcPattern_OutParam_ModifiedNode = v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValueModifiedNodeName_Node); + mmXML::mmXMLNodeI* v_psXMLCalcPattern_OutParam_Modified2ndNode = v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValueModifiedSecondNodeName_Node); + + if(v_psXMLCalcPattern_OutParam_ModifiedNode == NULL) + { + v_sOutValue = v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValue_Node)->GetText(); + } + else + { + if(v_psXMLCalcPattern_OutParam_Modified2ndNode == NULL) + { + mmString v_sModifierValue = GetValueOfParameter(p_psXMLCalcPatternDefinition,v_psXMLCalcPattern_OutParam_ModifiedNode->GetText()); + + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Multiplication) == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValue_Node)->GetText()) * + mmStringUtilities::StringToMMReal(v_sModifierValue)); + } + else + { + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Division) == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_sModifierValue)/ + mmStringUtilities::StringToMMReal(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValue_Node)->GetText())); + } + else + { + //mmReal v_rArg = mmStringUtilities::StringToMMReal(v_sModifierValue); + //mmReal v_rPow = mmStringUtilities::StringToMMReal(v_vCPOutParams[v_iCMOP]->FindChild(mmClouds::g_pComplexCalcXML_PatternOutputParamValue_Node)->GetText()); + //mmReal v_rRes = pow(v_rArg,v_rPow); + + v_sOutValue = mmStringUtilities::MMRealToString(pow(mmStringUtilities::StringToMMReal(v_sModifierValue), + mmStringUtilities::StringToMMReal(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValue_Node)->GetText()))); + }; + }; + } + else + { + mmString v_sModified1stValue = GetValueOfParameter(p_psXMLCalcPatternDefinition,v_psXMLCalcPattern_OutParam_ModifiedNode->GetText()); + + mmString v_sModified2ndValue = GetValueOfParameter(p_psXMLCalcPatternDefinition,v_vCPOutParams[v_iCMOP]-> + FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValueModifiedSecondNodeName_Node)-> + GetText()); + + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Addition) == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_sModified1stValue) + + mmStringUtilities::StringToMMReal(v_sModified2ndValue)); + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Subtraction) == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_sModified1stValue) - + mmStringUtilities::StringToMMReal(v_sModified2ndValue)); + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Multiplication) == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_sModified1stValue) * + mmStringUtilities::StringToMMReal(v_sModified2ndValue)); + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Division) == 0) + { + v_sOutValue = mmStringUtilities::MMRealToString(mmStringUtilities::StringToMMReal(v_sModified1stValue) / + mmStringUtilities::StringToMMReal(v_sModified2ndValue)); + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Minimum) == 0) + { + mmReal v_r1stValue = mmStringUtilities::StringToMMReal(v_sModified1stValue); + mmReal v_r2ndValue = mmStringUtilities::StringToMMReal(v_sModified2ndValue); + + if(v_r1stValue < v_r2ndValue) + { + v_sOutValue = v_sModified1stValue; + } + else + { + v_sOutValue = v_sModified2ndValue; + }; + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Maximum) == 0) + { + mmReal v_r1stValue = mmStringUtilities::StringToMMReal(v_sModified1stValue); + mmReal v_r2ndValue = mmStringUtilities::StringToMMReal(v_sModified2ndValue); + + if(v_r1stValue > v_r2ndValue) + { + v_sOutValue = v_sModified1stValue; + } + else + { + v_sOutValue = v_sModified2ndValue; + }; + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Equal) == 0) + { + mmReal v_r1stValue = mmStringUtilities::StringToMMReal(v_sModified1stValue); + mmReal v_r2ndValue = mmStringUtilities::StringToMMReal(v_sModified2ndValue); + + if(v_r1stValue == v_r2ndValue) + { + v_sOutValue = mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES; + } + else + { + v_sOutValue = mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_NO; + }; + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Greater) == 0) + { + mmReal v_r1stValue = mmStringUtilities::StringToMMReal(v_sModified1stValue); + mmReal v_r2ndValue = mmStringUtilities::StringToMMReal(v_sModified2ndValue); + + if(v_r1stValue > v_r2ndValue) + { + v_sOutValue = mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES; + } + else + { + v_sOutValue = mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_NO; + }; + }; + if(v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamOperation_Node)->GetText().compare(mmImages::g_pComplexCalcXML_PatternOutputFormula_Less) == 0) + { + mmReal v_r1stValue = mmStringUtilities::StringToMMReal(v_sModified1stValue); + mmReal v_r2ndValue = mmStringUtilities::StringToMMReal(v_sModified2ndValue); + + if(v_r1stValue < v_r2ndValue) + { + v_sOutValue = mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES; + } + else + { + v_sOutValue = mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_NO; + }; + }; + }; + }; + + break; + }; + }; + }; + + SendLogMessage(mmLog::info,mmString(L"GetValueOfParameter ")+ + p_sParamName + + mmString(L"=") + + v_sOutValue); + + SendLogMessage(mmLog::debug,mmString(L"End GetValueOfParameter")); + + return v_sOutValue; +} + +void mmImages::mmImagesComplexCalculationManagement::SetValueOfParameter( mmXML::mmXMLNodeI* p_psXMLCalcPatternDefinition, + mmString p_sParamName, + mmString p_sParamValue) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetValueOfParameter")); + + mmXML::mmXMLNodeI* v_psXMLCalcPattern_OutParams = + p_psXMLCalcPatternDefinition->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParams_Node); + std::vector v_vCPOutParams = v_psXMLCalcPattern_OutParams->GetChilds(); + mmInt v_iCPOPCount = v_vCPOutParams.size(); + for(mmInt v_iCMOP=0;v_iCMOP + FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamName_Node)-> + GetText()) == 0) + { + v_vCPOutParams[v_iCMOP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParamValue_Node)->SetText(p_sParamValue); + }; + }; + + mmXML::mmXMLNodeI* v_psXMLCalcPattern_InParams = + p_psXMLCalcPatternDefinition->FindChild(mmImages::g_pComplexCalcXML_PatternInputParams_Node); + std::vector v_vCPInParams = v_psXMLCalcPattern_InParams->GetChilds(); + mmInt v_iCPIPCount = v_vCPInParams.size(); + for(mmInt v_iCMIP=0;v_iCMIPFindChild(mmImages::g_pComplexCalcXML_PatternInputParamName_Node)->GetText()) == 0) + { + v_vCPInParams[v_iCMIP]->FindChild(mmImages::g_pComplexCalcXML_PatternInputParamValue_Node)->SetText(p_sParamValue); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End SetValueOfParameter")); +}; + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +mmString mmImages::mmImagesComplexCalculationManagement::GetInputParamsOfComplexCalculationPattern(mmString p_sCCPIDName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetInputParamsOfComplexCalculationPattern")); + + mmString v_sOutValue = L""; + + mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psXMLDoc->CopyXMLRootNodeStructure(GetInputParamsOfCCPattern(p_sCCPIDName)); + v_sOutValue = v_psXMLDoc->SaveToXMLBuffer(); + + SendLogMessage(mmLog::debug,mmString(L"End GetInputParamsOfComplexCalculationPattern")); + return v_sOutValue; +} +//--------------------------------------------------------------------------- +mmString mmImages::mmImagesComplexCalculationManagement::GetOutputParamsOfComplexCalculationPattern(mmString p_sCCPIDName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetOutputParamsOfComplexCalculationPattern")); + + mmString v_sOutValue = L""; + + mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psXMLDoc->CopyXMLRootNodeStructure(GetOutputParamsOfCCPattern(p_sCCPIDName)); + v_sOutValue = v_psXMLDoc->SaveToXMLBuffer(); + + SendLogMessage(mmLog::debug,mmString(L"End GetOutputParamsOfComplexCalculationPattern")); + return v_sOutValue; +} +//--------------------------------------------------------------------------- +mmString mmImages::mmImagesComplexCalculationManagement::SetInputParamsOfComplexCalculationPattern(mmString p_sCCPIDName, mmString p_sNewParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetInputParamsOfComplexCalculationPattern")); + + mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psXMLDoc->ParseXMLBuffer(p_sNewParams); + + mmXML::mmXMLNodeI* v_psXMLNode; + v_psXMLNode = GetInputParamsOfCCPattern(p_sCCPIDName); + mmXML::mmXMLNodeI* v_psXMLParent = v_psXMLNode->GetParent(); + delete v_psXMLNode; + mmString mtemp = v_psXMLDoc->GetXMLRootNode()->GetName(); + v_psXMLParent->AddChildWithStructure(v_psXMLDoc->GetXMLRootNode()); + + SendLogMessage(mmLog::debug,mmString(L"End SetInputParamsOfComplexCalculationPattern")); + return GetInputParamsOfComplexCalculationPattern(p_sCCPIDName); +} +//--------------------------------------------------------------------------- +mmString mmImages::mmImagesComplexCalculationManagement::SetOutputParamsOfComplexCalculationPattern(mmString p_sCCPIDName, mmString p_sNewParams) +{ + SendLogMessage(mmLog::debug,mmString(L"Start SetOutputParamsOfComplexCalculationPattern")); + + mmXML::mmXMLDocI* v_psXMLDoc = mmInterfaceInitializers::CreateXMLDocument(this->GetLogReceiver()); + v_psXMLDoc->ParseXMLBuffer(p_sNewParams); + + mmXML::mmXMLNodeI* v_psXMLNode; + v_psXMLNode = GetOutputParamsOfCCPattern(p_sCCPIDName); + mmXML::mmXMLNodeI* v_psXMLParent = v_psXMLNode->GetParent(); + delete v_psXMLNode; + mmString mtemp = v_psXMLDoc->GetXMLRootNode()->GetName(); + v_psXMLParent->AddChildWithStructure(v_psXMLDoc->GetXMLRootNode()); + + SendLogMessage(mmLog::debug,mmString(L"End SetOutputParamsOfComplexCalculationPattern")); + return GetOutputParamsOfComplexCalculationPattern(p_sCCPIDName); +} +//--------------------------------------------------------------------------- +mmXML::mmXMLNodeI* mmImages::mmImagesComplexCalculationManagement::GetInputParamsOfCCPattern(mmString p_sCCPIDName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetInputParamsOfCCPattern")); + + std::vector v_vCCPatterns = m_psXMLComplexPatternContainer->GetXMLRootNode()->GetChilds(); + + mmInt v_iCCPCount = v_vCCPatterns.size(); + for(mmInt v_iCCP=0;v_iCCPFindChild(mmImages::g_pComplexCalcXML_PatternIDName_Node)->GetText().compare(p_sCCPIDName) == 0) + { + mmXML::mmXMLNodeI* v_vCCPInputParams = v_vCCPatterns[v_iCCP]->FindChild(mmImages::g_pComplexCalcXML_PatternInputParams_Node); + + SendLogMessage(mmLog::debug,mmString(L"End GetInputParamsOfCCPattern")); + + return v_vCCPInputParams; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetInputParamsOfCCPattern")); + + return NULL; +} +//--------------------------------------------------------------------------- +mmXML::mmXMLNodeI* mmImages::mmImagesComplexCalculationManagement::GetOutputParamsOfCCPattern(mmString p_sCCPIDName) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetOutputParamsOfCCPattern")); + + std::vector v_vCCPatterns = m_psXMLComplexPatternContainer->GetXMLRootNode()->GetChilds(); + + mmInt v_iCCPCount = v_vCCPatterns.size(); + for(mmInt v_iCCP=0;v_iCCPFindChild(mmImages::g_pComplexCalcXML_PatternIDName_Node)->GetText().compare(p_sCCPIDName) == 0) + { + mmXML::mmXMLNodeI* v_vCCPInputParams = v_vCCPatterns[v_iCCP]->FindChild(mmImages::g_pComplexCalcXML_PatternOutputParams_Node); + + SendLogMessage(mmLog::debug,mmString(L"End GetOutputParamsOfCCPattern")); + + return v_vCCPInputParams; + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetOutputParamsOfCCPattern")); + + return NULL; +} +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- diff --git a/proj/libcalc2d/src/images/mmImagesStructure.cpp b/proj/libcalc2d/src/images/mmImagesStructure.cpp new file mode 100644 index 0000000..3ad9799 --- /dev/null +++ b/proj/libcalc2d/src/images/mmImagesStructure.cpp @@ -0,0 +1,704 @@ +#include + +#include + +#include +#include +#include + +#include +#include +#include + +#undef min +#undef max +#include +#include + + +struct FindByName { + FindByName(mmString const & p_sName) : m_sName(p_sName) {} + bool operator () (mmImages::mmLayer * const p_psLayer) { + return p_psLayer->GetName() == m_sName; + } + bool operator () (mmImages::mmImage * const p_psImage) { + return p_psImage->GetName() == m_sName; + } +private: + mmString const m_sName; +}; + +mmImages::mmLayer::mmLayer(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmReal const p_rDefaultValue, mmCallbackI * const p_psCallback) : + m_sName(p_sName), + m_rDefaultValue(p_rDefaultValue), + m_prValues((p_iWidth * p_iHeight) ? new mmReal[p_iWidth * p_iHeight] : NULL), + m_iWidth(p_iWidth), m_iHeight(p_iHeight), + m_psCallback(p_psCallback), + m_psLock(mmInterfaceInitializers::CreateReadWriteLock()) +{ + std::fill(m_prValues, m_prValues + m_iWidth * m_iHeight, m_rDefaultValue); + + if(m_psCallback != NULL) + m_psCallback->OnLayerCreate(this); +} + +mmImages::mmLayer::~mmLayer(void) { + delete m_psLock; + delete [] m_prValues; + + if(m_psCallback != NULL) + m_psCallback->OnLayerDestroy(this); +} + +mmUInt mmImages::mmLayer::GetWidth(void) const { + return m_iWidth; +} + +mmUInt mmImages::mmLayer::GetHeight(void) const { + return m_iHeight; +} + +mmReal mmImages::mmLayer::GetDefaultValue(void) const { + return m_rDefaultValue; +} + +void mmImages::mmLayer::Resize(mmUInt const p_iWidth, mmUInt const p_iHeight) { + m_psLock->LockForWrite(); + + if(p_iHeight * p_iWidth == 0) { + delete [] m_prValues; + m_prValues = NULL; + + m_iWidth = m_iHeight = 0; + } else { + mmReal * const v_prValues = new mmReal[p_iWidth * p_iHeight]; + + if(p_iWidth > m_iHeight || p_iWidth > m_iWidth) + std::fill(m_prValues, m_prValues + p_iWidth * p_iHeight, m_rDefaultValue); + + mmUInt const v_iCopyWidth = std::min(p_iWidth, m_iWidth), v_iCopyHeight = std::min(p_iHeight, m_iHeight); + for(mmUInt v_iY = 0; v_iY < v_iCopyHeight; ++v_iY) + ::memcpy(v_prValues + v_iY * v_iCopyWidth, m_prValues + v_iY * m_iWidth, v_iCopyWidth * sizeof(mmReal)); + + delete [] m_prValues; + + m_prValues = v_prValues; + m_iWidth = p_iWidth; + m_iHeight = p_iHeight; + + } + + m_sStats.Clear(); + + m_psLock->UnlockFromWrite(); + + if(m_psCallback != NULL) + m_psCallback->OnLayerPropertiesChange(this); +} + +mmImages::mmStats mmImages::mmLayer::GetStats(void) const { + return m_sStats; +} + +mmString mmImages::mmLayer::GetName(void) const { + return m_sName; +} + +void mmImages::mmLayer::SetName(mmString const & p_sName) { + m_psLock->LockForWrite(); + + m_sName = p_sName; + + m_psLock->UnlockFromWrite(); + + if(m_psCallback != NULL) + m_psCallback->OnLayerPropertiesChange(this); +} + +bool mmImages::mmLayer::GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmReal p_prValues[]) const { + if(p_iStart > m_iHeight || (p_iStart + p_iCount) > m_iHeight) + return false; + + m_psLock->LockForRead(); + + ::memcpy(p_prValues, m_prValues + p_iStart * m_iWidth, p_iCount * m_iWidth * sizeof(mmReal)); + + m_psLock->UnlockFromRead(); + + return true; +} + +bool mmImages::mmLayer::SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmReal const p_prValues[]) { + if(p_iStart > m_iHeight || (p_iStart + p_iCount) > m_iHeight) + return false; + + m_psLock->LockForWrite(); + + ::memcpy(m_prValues + p_iStart * m_iWidth, p_prValues, p_iCount * m_iWidth * sizeof(mmReal)); + + m_sStats.Update(m_prValues, m_iWidth * m_iHeight); + + m_psLock->UnlockFromWrite(); + + if(m_psCallback != NULL) + m_psCallback->OnLayerValuesChange(this); + + return true; +} + +bool mmImages::mmLayer::GetPixels(mmRect const & p_sRect, mmReal p_prValues[]) const { + if(p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + m_psLock->LockForRead(); + + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + ::memcpy(p_prValues + v_iRow * p_sRect.iWidth, m_prValues + (p_sRect.iTop + v_iRow) * m_iWidth + p_sRect.iLeft, p_sRect.iWidth * sizeof(mmReal)); + + m_psLock->UnlockFromRead(); + + return true; +} + +bool mmImages::mmLayer::SetPixels(mmRect const & p_sRect, mmReal const p_prValues[]) { + if(p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + m_psLock->LockForWrite(); + + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + ::memcpy(m_prValues + (p_sRect.iTop + v_iRow) * m_iWidth + p_sRect.iLeft, p_prValues + v_iRow * p_sRect.iWidth, p_sRect.iWidth * sizeof(mmReal)); + + m_sStats.Update(m_prValues, m_iWidth * m_iHeight); + + m_psLock->UnlockFromWrite(); + + if(m_psCallback != NULL) + m_psCallback->OnLayerValuesChange(this); + + return true; +} + +mmImages::mmImage::mmImage(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmPixelType const p_ePixelType, mmImageI::mmCallbackI * const p_psCallback) : + m_sName(p_sName), + m_iWidth(p_iWidth), m_iHeight(p_iHeight), + m_ePixelType(p_ePixelType), + m_psCallback(p_psCallback) +{ + switch(m_ePixelType) { + case mmP8: + m_sChannels.push_back(new mmLayer(L"I", m_iWidth, m_iHeight, 0.0, NULL)); + break; + case mmP24: + m_sChannels.push_back(new mmLayer(L"R", m_iWidth, m_iHeight, 0.0, NULL)); + m_sChannels.push_back(new mmLayer(L"G", m_iWidth, m_iHeight, 0.0, NULL)); + m_sChannels.push_back(new mmLayer(L"B", m_iWidth, m_iHeight, 0.0, NULL)); + break; + case mmP32: + m_sChannels.push_back(new mmLayer(L"R", m_iWidth, m_iHeight, 0.0, NULL)); + m_sChannels.push_back(new mmLayer(L"G", m_iWidth, m_iHeight, 0.0, NULL)); + m_sChannels.push_back(new mmLayer(L"B", m_iWidth, m_iHeight, 0.0, NULL)); + m_sChannels.push_back(new mmLayer(L"A", m_iWidth, m_iHeight, 0.0, NULL)); + break; + default: + break; + } + + if(m_psCallback != NULL) + m_psCallback->OnImageCreate(this); +} + +mmImages::mmImage::~mmImage(void) { + for(std::list::iterator v_iI = m_sChannels.begin(); v_iI != m_sChannels.end(); ++v_iI) + delete *v_iI; + + for(std::list::iterator v_iI = m_sLayers.begin(); v_iI != m_sLayers.end(); ++v_iI) + delete *v_iI; + + if(m_psCallback != NULL) + m_psCallback->OnImageDestroy(this); +} + +mmUInt mmImages::mmImage::GetWidth(void) const { + return m_iWidth; +} + +mmUInt mmImages::mmImage::GetHeight(void) const { + return m_iHeight; +} + +void mmImages::mmImage::Resize(mmUInt const p_iWidth, mmUInt const p_iHeight) { + for(std::list::iterator v_iI = m_sChannels.begin(); v_iI != m_sChannels.end(); ++v_iI) + (*v_iI)->Resize(p_iWidth, p_iHeight); + + if(m_psCallback != NULL) + m_psCallback->OnImagePropertiesChange(this); + + for(std::list::iterator v_iI = m_sLayers.begin(); v_iI != m_sLayers.end(); ++v_iI) + (*v_iI)->Resize(p_iWidth, p_iHeight); +} + +mmImages::mmImage::mmPixelType mmImages::mmImage::GetPixelType(void) const { + return m_ePixelType; +} + +mmString mmImages::mmImage::GetName(void) const { + return m_sName; +} + +void mmImages::mmImage::SetName(mmString const & p_sName) { + m_sName = p_sName; + + if(m_psCallback != NULL) + m_psCallback->OnImagePropertiesChange(this); +} + +mmImages::mmLayerI * mmImages::mmImage::GetChannel(mmUInt const p_iIndex) const { + if(p_iIndex < m_sChannels.size()) { + std::list::const_iterator v_sLayer = m_sChannels.begin(); + std::advance(v_sLayer, p_iIndex); + return *v_sLayer; + } else + return NULL; +} + +bool mmImages::mmImage::GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel8 p_psValues[]) const { + if(m_ePixelType != mmP8 || p_iStart > (m_iWidth * m_iHeight) || (p_iStart + p_iCount) > (m_iWidth * m_iHeight) || p_iCount == 0) + return false; + + m_sChannels.front()->GetRows(p_iStart, p_iCount, &p_psValues->rI); + + return true; +} + +bool mmImages::mmImage::GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel24 p_psValues[]) const { + if((m_ePixelType != mmP24 && m_ePixelType != mmP32) || p_iStart > (m_iWidth * m_iHeight) || (p_iStart + p_iCount) > (m_iWidth * m_iHeight) || p_iCount == 0) + return false; + + mmReal * v_prValues = new mmReal[p_iCount * m_iWidth]; + std::list::const_iterator v_sChannel = m_sChannels.begin(); + + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rR = v_prValues[v_iI]; + + ++v_sChannel; + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rG = v_prValues[v_iI]; + + ++v_sChannel; + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rB = v_prValues[v_iI]; + + delete [] v_prValues; + + return true; +} + +bool mmImages::mmImage::GetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel32 p_psValues[]) const { + if(m_ePixelType != mmP32 || p_iStart > (m_iWidth * m_iHeight) || (p_iStart + p_iCount) > (m_iWidth * m_iHeight) || p_iCount == 0) + return false; + + mmReal * v_prValues = new mmReal[p_iCount * m_iWidth]; + std::list::const_iterator v_sChannel = m_sChannels.begin(); + + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rR = v_prValues[v_iI]; + + ++v_sChannel; + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rG = v_prValues[v_iI]; + + ++v_sChannel; + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rB = v_prValues[v_iI]; + + ++v_sChannel; + (*v_sChannel)->GetRows(p_iStart, p_iCount, v_prValues); + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + p_psValues[v_iI].rA = v_prValues[v_iI]; + + delete [] v_prValues; + + return true; +} + +bool mmImages::mmImage::SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel8 const p_psValues[]) { + if(m_ePixelType != mmP8 || p_iStart > (m_iWidth * m_iHeight) || (p_iStart + p_iCount) > (m_iWidth * m_iHeight) || p_iCount == 0) + return false; + + m_sChannels.front()->SetRows(p_iStart, p_iCount, &p_psValues->rI); + + if(m_psCallback != NULL) + m_psCallback->OnImagePixelsChange(this); + + return true; +} + +bool mmImages::mmImage::SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel24 const p_psValues[]) { + if((m_ePixelType != mmP24 && m_ePixelType != mmP32) || p_iStart > (m_iWidth * m_iHeight) || (p_iStart + p_iCount) > (m_iWidth * m_iHeight) || p_iCount == 0) + return false; + + mmReal * v_prValues = new mmReal[p_iCount * m_iWidth]; + std::list::iterator v_sChannel = m_sChannels.begin(); + + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rR; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + ++v_sChannel; + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rG; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + ++v_sChannel; + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rB; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + delete [] v_prValues; + + if(m_psCallback != NULL) + m_psCallback->OnImagePixelsChange(this); + + return true; +} + +bool mmImages::mmImage::SetRows(mmUInt const p_iStart, mmUInt const p_iCount, mmPixel32 const p_psValues[]) { + if(m_ePixelType != mmP32 || p_iStart > (m_iWidth * m_iHeight) || (p_iStart + p_iCount) > (m_iWidth * m_iHeight) || p_iCount == 0) + return false; + + mmReal * v_prValues = new mmReal[p_iCount * m_iWidth]; + std::list::iterator v_sChannel = m_sChannels.begin(); + + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rR; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + ++v_sChannel; + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rG; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + ++v_sChannel; + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rB; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + ++v_sChannel; + for(mmUInt v_iI = 0; v_iI < p_iCount * m_iWidth; ++v_iI) + v_prValues[v_iI] = p_psValues[v_iI].rA; + (*v_sChannel)->SetRows(p_iStart, p_iCount, v_prValues); + + delete [] v_prValues; + + if(m_psCallback != NULL) + m_psCallback->OnImagePixelsChange(this); + + return true; +} + +bool mmImages::mmImage::GetPixels(mmRect const & p_sRect, mmPixel8 p_psValues[]) const { + if(m_ePixelType != mmP8 || p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + m_sChannels.front()->GetPixels(p_sRect, &p_psValues->rI); + + return true; +} + +bool mmImages::mmImage::GetPixels(mmRect const & p_sRect, mmPixel24 p_psValues[]) const { + if((m_ePixelType != mmP24 && m_ePixelType != mmP32) || p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + mmReal * v_prValues = new mmReal[p_sRect.iWidth * p_sRect.iHeight]; + std::list::const_iterator v_sChannel = m_sChannels.begin(); + + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rR = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + ++v_sChannel; + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rG = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + ++v_sChannel; + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rB = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + delete [] v_prValues; + + return true; +} + +bool mmImages::mmImage::GetPixels(mmRect const & p_sRect, mmPixel32 p_psValues[]) const { + if(m_ePixelType != mmP32 || p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + mmReal * v_prValues = new mmReal[p_sRect.iWidth * p_sRect.iHeight]; + std::list::const_iterator v_sChannel = m_sChannels.begin(); + + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rR = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + ++v_sChannel; + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rG = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + ++v_sChannel; + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rB = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + ++v_sChannel; + (*v_sChannel)->GetPixels(p_sRect, v_prValues); + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + p_psValues[v_iRow * p_sRect.iWidth + v_iPixel].rA = v_prValues[v_iRow * p_sRect.iWidth + v_iPixel]; + + delete [] v_prValues; + + return true; +} + +bool mmImages::mmImage::SetPixels(mmRect const & p_sRect, mmPixel8 const p_psValues[]) { + if(m_ePixelType != mmP8 || p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + m_sChannels.front()->SetPixels(p_sRect, &p_psValues->rI); + + if(m_psCallback != NULL) + m_psCallback->OnImagePixelsChange(this); + + return true; +} + +bool mmImages::mmImage::SetPixels(mmRect const & p_sRect, mmPixel24 const p_psValues[]) { + if((m_ePixelType != mmP24 && m_ePixelType != mmP32) || p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + mmReal * v_prValues = new mmReal[p_sRect.iWidth * p_sRect.iHeight]; + std::list::iterator v_sChannel = m_sChannels.begin(); + + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rR; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + ++v_sChannel; + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rG; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + ++v_sChannel; + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rB; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + delete [] v_prValues; + + if(m_psCallback != NULL) + m_psCallback->OnImagePixelsChange(this); + + return true; +} + +bool mmImages::mmImage::SetPixels(mmRect const & p_sRect, mmPixel32 const p_psValues[]) { + if(m_ePixelType != mmP32 || p_sRect.iLeft > m_iWidth || p_sRect.iTop > m_iHeight || (p_sRect.iLeft + p_sRect.iWidth) > m_iWidth || (p_sRect.iTop + p_sRect.iHeight) > m_iHeight || p_sRect.iWidth * p_sRect.iHeight == 0) + return false; + + mmReal * v_prValues = new mmReal[p_sRect.iWidth * p_sRect.iHeight]; + std::list::iterator v_sChannel = m_sChannels.begin(); + + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rR; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + ++v_sChannel; + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rG; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + ++v_sChannel; + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rB; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + ++v_sChannel; + for(mmUInt v_iRow = 0; v_iRow < p_sRect.iHeight; ++v_iRow) + for(mmUInt v_iPixel = 0; v_iPixel < p_sRect.iWidth; ++v_iPixel) + v_prValues[v_iRow * m_iWidth + v_iPixel] = p_psValues[v_iRow * m_iWidth + v_iPixel].rA; + (*v_sChannel)->SetPixels(p_sRect, v_prValues); + + delete [] v_prValues; + + if(m_psCallback != NULL) + m_psCallback->OnImagePixelsChange(this); + + return true; +} + +void mmImages::mmImage::SetRegionOfInterest(mmRect const & p_sRegion) { + m_sRegionOfInterest = p_sRegion; + + m_sRegionOfInterest.iLeft = std::min(m_sRegionOfInterest.iLeft, m_iWidth); + m_sRegionOfInterest.iTop = std::min(m_sRegionOfInterest.iTop, m_iHeight); + m_sRegionOfInterest.iWidth = std::min(m_sRegionOfInterest.iWidth, m_iWidth - m_sRegionOfInterest.iLeft); + m_sRegionOfInterest.iHeight = std::min(m_sRegionOfInterest.iHeight, m_iHeight - m_sRegionOfInterest.iTop); + + if(m_psCallback != NULL) + m_psCallback->OnImagePropertiesChange(this); +} + +mmRect mmImages::mmImage::GetRegionOfInterest(void) const { + return m_sRegionOfInterest; +} + +mmUInt mmImages::mmImage::CreateLayer(mmString const & p_sName, mmReal const p_rDefaultValue) { + m_sLayers.push_back(new mmLayer(p_sName, m_iWidth, m_iHeight, p_rDefaultValue, this)); + return static_cast(m_sLayers.size() - 1); +} + +mmUInt mmImages::mmImage::GetLayerCount(void) const { + return static_cast(m_sLayers.size()); +} + +mmImages::mmLayerI * mmImages::mmImage::GetLayer(mmUInt const p_iIndex) const { + if(p_iIndex < m_sLayers.size()) { + std::list::const_iterator v_sLayer = m_sLayers.begin(); + std::advance(m_sLayers.begin(), p_iIndex); + return *v_sLayer; + } else + return NULL; +} + +mmImages::mmLayerI * mmImages::mmImage::GetLayer(mmString const & p_sName) const { + std::list::const_iterator v_sLayer = std::find_if(m_sLayers.begin(), m_sLayers.end(), FindByName(p_sName)); + if(v_sLayer != m_sLayers.end()) + return *v_sLayer; + else + return NULL; +} + +bool mmImages::mmImage::DeleteLayer(mmUInt const p_iIndex) { + if(p_iIndex < m_sLayers.size()) { + std::list::iterator v_sLayer = m_sLayers.begin(); + std::advance(v_sLayer, p_iIndex); + delete *v_sLayer; + m_sLayers.erase(v_sLayer); + return true; + } else + return false; +} + +bool mmImages::mmImage::DeleteLayer(mmString const & p_sName) { + std::list::iterator v_sLayer = std::find_if(m_sLayers.begin(), m_sLayers.end(), FindByName(p_sName)); + if(v_sLayer != m_sLayers.end()) { + delete *v_sLayer; + m_sLayers.erase(v_sLayer); + return true; + } else + return false; +} + +void mmImages::mmImage::SetMetadata(mmString const & p_sMetadata) { + m_sMetadata = p_sMetadata; +} + +mmString mmImages::mmImage::GetMetadata(void) { + return m_sMetadata; +} + +void mmImages::mmImage::OnLayerCreate(mmLayerI * p_psLayer) { + if(m_psCallback != NULL) + m_psCallback->OnLayerCreate(this, p_psLayer); +} + +void mmImages::mmImage::OnLayerDestroy(mmLayerI * p_psLayer) { + if(m_psCallback != NULL) + m_psCallback->OnLayerDestroy(this, p_psLayer); +} + +void mmImages::mmImage::OnLayerPropertiesChange(mmLayerI * p_psLayer) { + if(m_psCallback != NULL) + m_psCallback->OnLayerPropertiesChange(this, p_psLayer); +} + +void mmImages::mmImage::OnLayerValuesChange(mmLayerI * p_psLayer) { + if(m_psCallback != NULL) + m_psCallback->OnLayerValuesChange(this, p_psLayer); +} + +mmImages::mmImageStructure::mmImageStructure(mmImageI::mmCallbackI * const p_psCallback) : + m_psCallback(p_psCallback) +{} + +mmImages::mmImageStructure::~mmImageStructure(void) { +} + +mmUInt mmImages::mmImageStructure::CreateImage(mmString const & p_sName, mmUInt const p_iWidth, mmUInt const p_iHeight, mmImageI::mmPixelType const p_ePixelType) { + m_sImages.push_back(new mmImage(p_sName, p_iWidth, p_iHeight, p_ePixelType, m_psCallback)); + return static_cast(m_sImages.size() - 1); +} + +mmUInt mmImages::mmImageStructure::GetImageCount(void) const { + return static_cast(m_sImages.size()); +} + +mmImages::mmImageI * mmImages::mmImageStructure::GetImage(mmUInt const p_iIndex) const { + if(p_iIndex < m_sImages.size()) { + std::list::const_iterator v_sImage = m_sImages.begin(); + std::advance(m_sImages.begin(), p_iIndex); + return *v_sImage; + } else + return NULL; +} + +mmImages::mmImageI * mmImages::mmImageStructure::GetImage(mmString const & p_sName) const { + std::list::const_iterator v_sImage = std::find_if(m_sImages.begin(), m_sImages.end(), FindByName(p_sName)); + if(v_sImage != m_sImages.end()) + return *v_sImage; + else + return NULL; +} + +bool mmImages::mmImageStructure::DeleteImage(mmUInt const p_iIndex) { + if(p_iIndex < m_sImages.size()) { + std::list::iterator v_sImage = m_sImages.begin(); + std::advance(v_sImage, p_iIndex); + delete *v_sImage; + m_sImages.erase(v_sImage); + return true; + } else + return false; +} + +bool mmImages::mmImageStructure::DeleteImage(mmString const & p_sName) { + std::list::iterator v_sImage = std::find_if(m_sImages.begin(), m_sImages.end(), FindByName(p_sName)); + if(v_sImage != m_sImages.end()) { + delete *v_sImage; + m_sImages.erase(v_sImage); + return true; + } else + return false; +} \ No newline at end of file diff --git a/proj/libcalc2d/src/interfaces/mmGlobalInterfacesStorage.cpp b/proj/libcalc2d/src/interfaces/mmGlobalInterfacesStorage.cpp new file mode 100644 index 0000000..a3b956e --- /dev/null +++ b/proj/libcalc2d/src/interfaces/mmGlobalInterfacesStorage.cpp @@ -0,0 +1,52 @@ +#include + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmInterfacesStorage::mmGlobalInterfacesStorage +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//mmInterfacesStorage::mmGlobalInterfacesStorage::mmGlobalInterfacesStorage(mmMemory::mmMemoryManagerI* p_psMemoryManager, +// mmLog::mmLogReceiverI* p_psLogReceiver ): mmLog::mmLogSender(L"mmInterfacesStorage::mmGlobalInterfacesStorage",p_psLogReceiver) +// +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); +// +// m_psMemoryManager = p_psMemoryManager; +// +// SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +//} +// +//mmInterfacesStorage::mmGlobalInterfacesStorage::~mmGlobalInterfacesStorage() +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); +// +// SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +//} +// +//mmMemory::mmMemoryManagerI* mmInterfacesStorage::mmGlobalInterfacesStorage::GetMemoryManager(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetMemoryManager")); +// +// SendLogMessage(mmLog::debug,mmString(L"End GetMemoryManager")); +// +// return m_psMemoryManager; +//} +// +//mmLog::mmLogReceiverI* mmInterfacesStorage::mmGlobalInterfacesStorage::GetLogManager(void) +//{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetLogManager")); +// +// SendLogMessage(mmLog::debug,mmString(L"End GetLogManager")); +// +// return this->GetLogReceiver(); +//} +// +mmInterfacesStorage::mmGlobalInterfacesStorage::mmGlobalInterfacesStorage(mmLog::mmLogReceiverI* p_psLogReceiver ) : m_psLogReceiver(p_psLogReceiver) {} + +mmLog::mmLogReceiverI* mmInterfacesStorage::mmGlobalInterfacesStorage::GetLogManager(void) { + return m_psLogReceiver; +} + +mmLog::mmLogReceiverI* mmInterfacesStorage::mmGlobalInterfacesStorage::GetLogReceiver(void) { + return m_psLogReceiver; +} diff --git a/proj/libcalc2d/src/interfaces/mmIHardware.cpp b/proj/libcalc2d/src/interfaces/mmIHardware.cpp new file mode 100644 index 0000000..1c16d16 --- /dev/null +++ b/proj/libcalc2d/src/interfaces/mmIHardware.cpp @@ -0,0 +1,51 @@ +#include + +mmInt mmImageProcessing::GetPixelSize(mmImageProcessing::ePixelType p_ePixelType) +{ + mmInt v_iResult; + + switch(p_ePixelType) + { + case mmImageProcessing::pixel_R8G8B8: + { + v_iResult = 3; + }; + break; + case mmImageProcessing::pixel_B8G8R8: + { + v_iResult = 3; + }; + break; + case mmImageProcessing::pixel_Gray8: + { + v_iResult = 1; + }; + break; + case mmImageProcessing::pixel_Gray16: + { + v_iResult = 2; + }; + break; + case mmImageProcessing::pixel_B8G8R8A8: + { + v_iResult = 4; + }; + break; + case mmImageProcessing::pixel_R8G8B8A8: + { + v_iResult = 4; + }; + break; + case mmImageProcessing::pixel_R16G16B16: + { + v_iResult = 6; + }; + break; + default: + { + throw mmError(mmeImageProcessingUnknownPixelType); + }; + }; + + return v_iResult; +} diff --git a/proj/libcalc2d/src/interfaces/mmIImages.cpp b/proj/libcalc2d/src/interfaces/mmIImages.cpp new file mode 100644 index 0000000..8ad7046 --- /dev/null +++ b/proj/libcalc2d/src/interfaces/mmIImages.cpp @@ -0,0 +1,62 @@ +#include + +#include + +mmUInt const mmImages::mmImageI::iInvalid = std::numeric_limits::max(); +mmUInt const mmImages::mmLayerI::iInvalid = std::numeric_limits::max(); + +mmReal const mmImages::mmStats::rInvalid = std::numeric_limits::quiet_NaN(); + +mmImages::mmStats::mmStats(void) : rMin(rInvalid), rMax(rInvalid), rAverage(rInvalid), rStdDev(rInvalid) +{} + +void mmImages::mmStats::Clear(void) { + rMin = rInvalid; + rMax = rInvalid; + rAverage = rInvalid; + rStdDev = rInvalid; +} + +void mmImages::mmStats::Update(mmReal const p_prValues[], mmUInt const p_iSize) { + if(p_iSize == 0) + return; + + rAverage = 0.0; + rStdDev = 0.0; + rMin = std::numeric_limits::max(); + rMax = -std::numeric_limits::max(); + + for(mmUInt v_iI = 0; v_iI < p_iSize; ++v_iI) { + rAverage += p_prValues[v_iI]; + if(p_prValues[v_iI] < rMin) + rMin = p_prValues[v_iI]; + if(p_prValues[v_iI] > rMax) + rMax = p_prValues[v_iI]; + } + rAverage /= static_cast(p_iSize); + + mmReal v_rTemp; + for(mmUInt v_iI = 0; v_iI < p_iSize; ++v_iI) { + v_rTemp = p_prValues[v_iI] - rAverage; + rStdDev += v_rTemp * v_rTemp; + } + rStdDev = ::sqrt(rStdDev / static_cast(p_iSize)); +} + +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_ImageName = L"Image name..."; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_ImagesNames = L"Image names..."; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_ImageCount_All = L"All"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_DataLayerName = L"Data layer name..."; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_RealValue = L"Real value..."; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_IntegerValue = L"Integer value..."; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue = L"Yes/No value..."; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_YES = L"YES"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue_NO = L"NO"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_String = L"String value..."; + +const wchar_t* mmImages::g_pAutoCalcXML_INParams_Node = L"AutoINParams"; +const wchar_t* mmImages::g_pAutoCalcXML_OUTParams_Node = L"AutoOUTParams"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_Param_Node = L"AutoParam"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamName_Node = L"AutoParamName"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamType_Node = L"AutoParamType"; +const wchar_t* mmImages::g_pAutoCalcXML_Params_ParamValue_Node = L"AutoParamValue"; diff --git a/proj/libcalc2d/src/log/mmLogFile.cpp b/proj/libcalc2d/src/log/mmLogFile.cpp new file mode 100644 index 0000000..ba7210d --- /dev/null +++ b/proj/libcalc2d/src/log/mmLogFile.cpp @@ -0,0 +1,48 @@ +#include + +#include + +mmLog::mmLogFile::mmLogFile(mmString p_sLogFileName) +{ + m_psLogFile = mmInterfaceInitializers::CreateTextFileForWrite(); + + m_psLogFile->Open(p_sLogFileName,mmFileIO::trunc_for_write); +} + +mmLog::mmLogFile::~mmLogFile() +{ + m_psLogFile->Flush(); + + delete m_psLogFile; +} + +void mmLog::mmLogFile::SendLogMessage(eLogMessagePriority p_ePriority,mmString* p_psString) +{ + switch(p_ePriority) + { + case mmLog::debug: + { + m_psLogFile->WriteChar('D'); + }; + break; + case mmLog::info: + { + m_psLogFile->WriteChar('I'); + }; + break; + case mmLog::user: + { + m_psLogFile->WriteChar('U'); + }; + break; + case mmLog::critical: + { + m_psLogFile->WriteChar('C'); + }; + break; + }; + + m_psLogFile->WriteChar(' '); + + m_psLogFile->WriteLine(*p_psString); +} diff --git a/proj/libcalc2d/src/log/mmLogRedirector.cpp b/proj/libcalc2d/src/log/mmLogRedirector.cpp new file mode 100644 index 0000000..d519df9 --- /dev/null +++ b/proj/libcalc2d/src/log/mmLogRedirector.cpp @@ -0,0 +1,119 @@ +#include + +#include + +mmLog::mmLogRedirector::mmLogRedirector() +{ + m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(); +} + +mmLog::mmLogRedirector::~mmLogRedirector() +{ + delete m_psExclusiveLock; +} + +bool mmLog::mmLogRedirector::IsRegistered(mmLogReceiverI* p_pLogReceiver) +{ + mmInt v_iCount = static_cast(m_sReceiverTable.size()); + mmInt v_i; + bool bIsFound = false; + + for(v_i=0;v_i(m_sReceiverTable.size()); + mmInt v_i; + + // sprawdzam czy nie ma pustego elementu + for(v_i=0;v_i(m_sReceiverTable.size()-1); +} + +void mmLog::mmLogRedirector::RegisterLogReceiver(eLogMessagePriority p_eMinPriority, + mmLogReceiverI* p_pLogReceiver) +{ + bool bIsRegistered; + + // jeśli jest już zarejestrowana to zgłaszam wyjątek + m_psExclusiveLock->Lock(); + bIsRegistered = IsRegistered(p_pLogReceiver); + m_psExclusiveLock->Unlock(); + if(bIsRegistered) + { + throw mmError(mmeLogReceiverObjectAlreadyRegistered); + }; + + // tworzę nowy element + m_psExclusiveLock->Lock(); + mmInt v_iFreeIndex = GetFreeReceiverTableIndex(); + m_sReceiverTable[v_iFreeIndex].ePriority = p_eMinPriority; + m_sReceiverTable[v_iFreeIndex].pReceiver = p_pLogReceiver; + m_psExclusiveLock->Unlock(); +} + +void mmLog::mmLogRedirector::UnregisterLogReceiver(mmLogReceiverI* p_pLogReceiver) +{ + mmInt v_iUnregisterCount = 0; + + m_psExclusiveLock->Lock(); + mmInt v_iCount = static_cast(m_sReceiverTable.size()); + mmInt v_i; + + for(v_i=0;v_iUnlock(); + + if(v_iUnregisterCount != 1) + { + throw mmError(mmeLogReceiverObjectIsNotRegistered); + }; +} + +void mmLog::mmLogRedirector::SendLogMessage(eLogMessagePriority p_ePriority,mmString* p_psString) +{ + m_psExclusiveLock->Lock(); + mmInt v_iCount = static_cast(m_sReceiverTable.size()); + mmInt v_i; + + for(v_i=0;v_iSendLogMessage(p_ePriority,p_psString); + }; + }; + }; + m_psExclusiveLock->Unlock(); +} + diff --git a/proj/libcalc2d/src/log/mmLogSender.cpp b/proj/libcalc2d/src/log/mmLogSender.cpp new file mode 100644 index 0000000..a3e02fa --- /dev/null +++ b/proj/libcalc2d/src/log/mmLogSender.cpp @@ -0,0 +1,55 @@ +#include + +#include +#include + +mmLog::mmLogSender::mmLogSender(mmString p_sClassName,mmLog::mmLogReceiverI* p_psLog) +{ + m_sClassName = p_sClassName; + m_psLog = p_psLog; +} + +void mmLog::mmLogSender::SendLogMessage(eLogMessagePriority p_ePriority,mmString p_sString) +{ + if(m_psLog != NULL) + { + mmString v_sLogMessage = mmStringUtilities::GetCurrentDateTimeString() + + mmString(L" ") + + mmStringUtilities::MMRealToString(mmOperatingSystem::GetApplicationTime(),3) + + mmString(L" ") + + mmStringUtilities::MMIntToString(mmOperatingSystem::GetCurrentThreadID()) + + mmString(L" ") + + m_sClassName + + mmString(L" ") + + mmStringUtilities::PointerToString(this) + + mmString(L" ") + + p_sString; + + m_psLog->SendLogMessage(p_ePriority,&v_sLogMessage); + }; +} + +mmLog::mmLogReceiverI* mmLog::mmLogSender::GetLogReceiver(void) +{ + return m_psLog; +} + +void mmLog::mmLogSender::SendLogMessage(void* p_pClassPointer,eLogMessagePriority p_ePriority,mmString p_sString) +{ + if(m_psLog != NULL) + { + mmString v_sLogMessage = mmStringUtilities::GetCurrentDateTimeString() + + mmString(L" ") + + mmStringUtilities::MMRealToString(mmOperatingSystem::GetApplicationTime(),3) + + mmString(L" ") + + mmStringUtilities::MMIntToString(mmOperatingSystem::GetCurrentThreadID()) + + mmString(L" ") + + m_sClassName + + mmString(L" ") + + mmStringUtilities::PointerToString(p_pClassPointer) + + mmString(L" ") + + p_sString; + + m_psLog->SendLogMessage(p_ePriority,&v_sLogMessage); + }; +} diff --git a/proj/libcalc2d/src/mmError.cpp b/proj/libcalc2d/src/mmError.cpp new file mode 100644 index 0000000..792585a --- /dev/null +++ b/proj/libcalc2d/src/mmError.cpp @@ -0,0 +1,25 @@ +#include + +//////////////////////////////////////////////////////////////////////////////// +/// Table with error numbers. Table ends with -1 value. +//////////////////////////////////////////////////////////////////////////////// +//const mmInt g_tErrorCodesTable[] = {20000, +// 20100, +// -1}; + +mmError::mmError(mmInt p_iErrID) +{ + m_iErrorID = p_iErrID; +} + +mmInt mmError::GetErrorCode(void) +{ + return m_iErrorID; +} + +mmString mmError::GetErrorString(void) +{ + // TODO + + return mmString(L"no error string"); +} diff --git a/proj/libcalc2d/src/mmInterfaceInitializers.cpp b/proj/libcalc2d/src/mmInterfaceInitializers.cpp new file mode 100644 index 0000000..ade8b44 --- /dev/null +++ b/proj/libcalc2d/src/mmInterfaceInitializers.cpp @@ -0,0 +1,167 @@ +#include +#include +#include +#include +#include + +#include +#include +#include + +mmSynchronize::mmExclusiveLockI* mmInterfaceInitializers::CreateExclusiveLock(mmLog::mmLogReceiverI *p_psLogReceiver) +{ + try + { + return (new mmSynchronize::mmExclusiveLockCSWindows(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmSynchronize::mmReadWriteLockI* mmInterfaceInitializers::CreateReadWriteLock(mmLog::mmLogReceiverI *p_psLogReceiver) +{ + try + { + return (new mmSynchronize::mmReadWriteLockCSWindows(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + + +mmFileIO::mmFileUtilsI* mmInterfaceInitializers::CreateFileUtils(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmFileIO::mmFileUtilsSTD(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmFileIO::mmTextFileReadI* mmInterfaceInitializers::CreateTextFileForRead(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmFileIO::mmTextFileReadSTD(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmFileIO::mmBinaryFileReadI* mmInterfaceInitializers::CreateBinaryFileForRead(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmFileIO::mmBinaryFileReadSTD(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmFileIO::mmTextFileWriteI* mmInterfaceInitializers::CreateTextFileForWrite(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmFileIO::mmTextFileWriteSTD(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmFileIO::mmBinaryFileWriteI* mmInterfaceInitializers::CreateBinaryFileForWrite(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmFileIO::mmBinaryFileWriteSTD(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + + +mmLog::mmLogReceiverI* mmInterfaceInitializers::CreateLogFile(mmString p_sLogFileName) +{ + try + { + return (new mmLog::mmLogFile(p_sLogFileName)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmXML::mmXMLDocI* mmInterfaceInitializers::CreateXMLDocument(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmXML::mmXMLDocBB(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmXML::mmXMLNodeI* mmInterfaceInitializers::CreateXMLNode(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmXML::mmXMLNodeBB(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} +mmThread::mmThreadI* mmInterfaceInitializers::CreateDefaultThread(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmThread::mmThreadWindows(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmImages::mmImageStructureI* mmInterfaceInitializers::CreateDefaultImageStructure(mmImages::mmImageI::mmCallbackI * p_psCallback, mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmImages::mmImageStructure(p_psCallback)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + +mmImages::mmImagesCalculationMethodContainerI* mmInterfaceInitializers::CreateDefaultImagesCalculationMethodContainer(mmLog::mmLogReceiverI* p_psLogReceiver) +{ + try + { + return (new mmImages::mmImagesCalculationMethodContainerForWindows(p_psLogReceiver)); + } + catch(std::bad_alloc) + { + throw mmError(mmeBadAlloc); + }; +} + diff --git a/proj/libcalc2d/src/mmOperatingSystemCalls.cpp b/proj/libcalc2d/src/mmOperatingSystemCalls.cpp new file mode 100644 index 0000000..6b7c8fe --- /dev/null +++ b/proj/libcalc2d/src/mmOperatingSystemCalls.cpp @@ -0,0 +1,269 @@ + +#pragma hdrstop + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +mmInt mmOperatingSystem::GetCurrentThreadID(void) +{ + return GetCurrentThreadId(); +} + +void mmOperatingSystem::CreateDir(mmString p_sDirName) +{ + int v_iRes = _wmkdir(p_sDirName.c_str()); + if(v_iRes != 0) + { + switch(errno) + { + case EACCES: + { + throw mmError(mmeFileIOPermissionToFileDenied); + }; + case ENOENT: + { + throw mmError(mmeFileIONoSuchFileOrDirectory); + }; + default: + { + throw mmError(mmeUnknownError); + }; + }; + }; +} + +void mmOperatingSystem::RemoveDir(mmString p_sDirName) +{ + int v_iRes = _wrmdir(p_sDirName.c_str()); + if(v_iRes != 0) + { + switch(errno) + { + case EACCES: + { + throw mmError(mmeFileIOPermissionToFileDenied); + }; + case ENOENT: + { + throw mmError(mmeFileIONoSuchFileOrDirectory); + }; + default: + { + throw mmError(mmeUnknownError); + }; + }; + }; +} + +bool mmOperatingSystem::IsExistingDir(mmString p_sDirName) +{ + bool v_bRes = false; + + // pobieram aktywny dysk i ścieżkę + int v_iDriveNo = _getdrive(); + wchar_t* v_pcCurDir = _wgetcwd(NULL,_MAX_PATH); + if(v_pcCurDir == NULL) + { + throw mmError(mmeBadAlloc); + }; + + // prubuję przejść do ścieżki p_sDirName + if(_wchdir(p_sDirName.c_str()) == 0) + { + v_bRes = true; + }; + + // przywracam poprzedni dysk i ścieżkę + _chdrive(v_iDriveNo); + if(_wchdir(v_pcCurDir) != 0) + { + throw mmError(mmeUnknownError); + }; + + // zwalniam pamięć przydzieloną przez getcwd + free(v_pcCurDir); + + return v_bRes; +} + +mmString mmOperatingSystem::GetApplicationDirectory(void) +{ + + + TCHAR v_ptcAppPath[MAX_PATH + 1]; + + // Clear destination buffer + ::ZeroMemory( v_ptcAppPath, sizeof(v_ptcAppPath) ); + + // Get fully-qualified path for the executable + if ( ! ::GetModuleFileName(NULL, v_ptcAppPath, MAX_PATH ) ) + { + // Failure + return (L""); + } + mmString v_sAppPath( v_ptcAppPath ); + + v_sAppPath.resize(v_sAppPath.find_last_of(L"\\")); + + return v_sAppPath; +} + +mmString mmOperatingSystem::GetApplicationName(void) +{ + + + MAX_PATH; + TCHAR v_ptcAppPath[MAX_PATH + 1]; + + + // Clear destination buffer + ::ZeroMemory( v_ptcAppPath, sizeof(v_ptcAppPath) ); + + // Get fully-qualified path for the executable + if ( ! ::GetModuleFileName(NULL, v_ptcAppPath, MAX_PATH ) ) + { + // Failure + return (L""); + } + + mmString v_sAppNameAndPath( v_ptcAppPath ); + + mmString v_sAppName = v_sAppNameAndPath.substr(v_sAppNameAndPath.find_last_of(L"\\")+1,v_sAppNameAndPath.size()-v_sAppNameAndPath.find_last_of(L"\\")-1); + + return v_sAppName; + +} + +mmString mmOperatingSystem::GetCurrentWorkingDir(void) +{ + wchar_t v_ctDirectory[_MAX_PATH]; + + wchar_t v_cLetter[2]; + v_cLetter[0] = 'A'+_getdrive()-1; + v_cLetter[1] = 0; + if(_wgetcwd(v_ctDirectory,_MAX_PATH) == NULL) + { + throw mmError(mmeUnknownError); + }; + + mmString v_sWorkingDir = mmString(v_cLetter) + + mmString(L":\\") + + mmString(v_ctDirectory); + + return v_sWorkingDir; +} + +std::vector mmOperatingSystem::GetDirectoryElements(mmString p_sDirName, + mmString p_sDirWildcards) +{ + std::vector v_sDirElements; + _wfinddata_t v_sActFileInfo; + mmFileIO::mmFileUtilsI::sDirElement v_sActElement; + intptr_t v_hSearchHandle; + int v_iRes = 0; + + // pobieram pierwszy element + mmString v_sString((p_sDirName + mmString(L"\\") + p_sDirWildcards).c_str()); + v_hSearchHandle = _wfindfirst(const_cast(v_sString.c_str()), &v_sActFileInfo); + if(v_hSearchHandle == -1) + { + //if( (_doserrno == ENOENT) || (_doserrno == EINVAL) ) + { + throw mmError(mmeFileIONoSuchFileOrDirectory); + } + //else + //{ + // throw mmError(mmeUnknownError); + //}; + } + else + { + while(v_iRes != -1) + { + // przetwarzam element + v_sActElement.sName = v_sActFileInfo.name; + // nie przetwarzam elementów "." i ".." + if( (v_sActElement.sName.compare(L".") != 0) && (v_sActElement.sName.compare(L"..") != 0) ) + { + if(v_sActFileInfo.attrib & _A_SUBDIR) + { + v_sActElement.bFile = false; + } + else + { + v_sActElement.bFile = true; + }; + v_sDirElements.push_back(v_sActElement); + }; + // pobieram następny + v_iRes = _wfindnext(v_hSearchHandle,&v_sActFileInfo); + }; + }; + + _findclose(v_hSearchHandle); + + return v_sDirElements; +} + +bool mmOperatingSystem::IsExistingFile(mmString p_sFileName) +{ + return ::_waccess(p_sFileName.c_str(), 0) != -1; +} + +mmReal mmOperatingSystem::GetApplicationTime(void) +{ + std::clock_t v_sCurrentClock; + + v_sCurrentClock = clock(); + return (static_cast(v_sCurrentClock)/CLK_TCK); +} + + +void mmOperatingSystem::StopThread(mmInt p_iMiliSeconds) +{ + Sleep(p_iMiliSeconds); +} + +mmString mmOperatingSystem::GetUniqueIDString(void) +{ + mmString v_sOutIDString; + + // Hard Drive ID + DWORD v_sSN,v_sDW1,v_sDW2; + wchar_t v_cS1[256]; + wchar_t v_cS2[256]; + + mmString v_sWinDir = _wgetenv(L"windir"); + mmString v_sDrive = v_sWinDir.substr(0,3); + GetVolumeInformation(v_sDrive.c_str(),v_cS1,256,&v_sSN,&v_sDW1,&v_sDW2,v_cS2,256); + + wchar_t v_cHDD[256]; + swprintf(v_cHDD,L"%d",v_sSN); + mmString v_sHDD = v_cHDD; + + // Program tick count + std::clock_t v_sCurrentClock = v_sCurrentClock = clock(); + + wchar_t v_cCLK[256]; + swprintf(v_cCLK,L"%d",v_sCurrentClock); + mmString v_sCLK = v_cCLK; + + // date time + mmString v_sDateTime = mmStringUtilities::GetCurrentDateTimeString(); + + v_sOutIDString = v_sHDD + v_sCLK + mmString(L"_") + v_sDateTime; + + return v_sOutIDString; +} + diff --git a/proj/libcalc2d/src/mmPixel.cpp b/proj/libcalc2d/src/mmPixel.cpp new file mode 100644 index 0000000..2b77a3e --- /dev/null +++ b/proj/libcalc2d/src/mmPixel.cpp @@ -0,0 +1,246 @@ +#include + +mmUInt const mmPixel8::iComponents = 1; +mmPixel8::mmPixel8(void) : rI(0.0) {} +mmPixel8::mmPixel8(mmReal const p_rI) : rI(p_rI) {} + +mmUInt const mmPixel24::iComponents = 3; +mmPixel24::mmPixel24(void) : rR(0.0), rG(0.0), rB(0.0) {} +mmPixel24::mmPixel24(mmReal const p_rR, mmReal const p_rG, mmReal const p_rB) : rR(p_rR), rG(p_rG), rB(p_rB) {} +mmPixel24::mmPixel24(mmPixel8 const & p_smmPixel8) : rR(p_smmPixel8.rI), rG(p_smmPixel8.rI), rB(p_smmPixel8.rI) {} + +mmUInt const mmPixel32::iComponents = 4; +mmPixel32::mmPixel32(void) : rR(0.0), rG(0.0), rB(0.0), rA(0.0) {} +mmPixel32::mmPixel32(mmReal const p_rR, mmReal const p_rG, mmReal const p_rB, mmReal const p_rA) : rR(p_rR), rG(p_rG), rB(p_rB), rA(p_rA) {} +mmPixel32::mmPixel32(mmPixel8 const & p_smmPixel8) : rR(p_smmPixel8.rI), rG(p_smmPixel8.rI), rB(p_smmPixel8.rI), rA(0.0) {} +mmPixel32::mmPixel32(mmPixel24 const & p_smmPixel24) : rR(p_smmPixel24.rR), rG(p_smmPixel24.rG), rB(p_smmPixel24.rB), rA(0.0) {} + +inline mmPixel8 operator + (mmPixel8 p_sP1, mmPixel8 const & p_sP2) { + p_sP1.rI += p_sP2.rI; + + return p_sP1; +} + +inline mmPixel8 operator - (mmPixel8 p_sP1, mmPixel8 const & p_sP2) { + p_sP1.rI -= p_sP2.rI; + + return p_sP1; +} + +inline mmPixel8 operator += (mmPixel8 & p_sP1, mmPixel8 const & p_sP2) { + p_sP1.rI += p_sP2.rI; + + return p_sP1; +} + +inline mmPixel8 operator -= (mmPixel8 & p_sP1, mmPixel8 const & p_sP2) { + p_sP1.rI -= p_sP2.rI; + + return p_sP1; +} + +inline mmPixel8 operator * (mmPixel8 p_sP, mmReal const p_rS) { + p_sP.rI *= p_rS; + + return p_sP; +} + +inline mmPixel8 operator * (mmReal const p_rS, mmPixel8 p_sP) { + p_sP.rI *= p_rS; + + return p_sP; +} + +inline mmPixel8 operator / (mmPixel8 p_sP, mmReal const p_rS) { + p_sP.rI /= p_rS; + + return p_sP; +} + +inline mmPixel8 operator *= (mmPixel8 & p_sP, mmReal const p_rS) { + p_sP.rI *= p_rS; + + return p_sP; +} + +inline mmPixel8 operator *= (mmReal const p_rS, mmPixel8 & p_sP) { + p_sP.rI *= p_rS; + + return p_sP; +} + +inline mmPixel8 operator /= (mmPixel8 & p_sP, mmReal const p_rS) { + p_sP.rI /= p_rS; + + return p_sP; +} + +inline mmPixel24 operator + (mmPixel24 p_sP1, mmPixel24 const & p_sP2) { + p_sP1.rR += p_sP2.rR; + p_sP1.rG += p_sP2.rG; + p_sP1.rB += p_sP2.rB; + + return p_sP1; +} + +inline mmPixel24 operator - (mmPixel24 p_sP1, mmPixel24 const & p_sP2) { + p_sP1.rR -= p_sP2.rR; + p_sP1.rG -= p_sP2.rG; + p_sP1.rB -= p_sP2.rB; + + return p_sP1; +} + +inline mmPixel24 operator += (mmPixel24 & p_sP1, mmPixel24 const & p_sP2) { + p_sP1.rR += p_sP2.rR; + p_sP1.rG += p_sP2.rG; + p_sP1.rB += p_sP2.rB; + + return p_sP1; +} + +inline mmPixel24 operator -= (mmPixel24 & p_sP1, mmPixel24 const & p_sP2) { + p_sP1.rR -= p_sP2.rR; + p_sP1.rG -= p_sP2.rG; + p_sP1.rB -= p_sP2.rB; + + return p_sP1; +} + +inline mmPixel24 operator * (mmPixel24 p_sP, mmReal const p_rS) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + + return p_sP; +} + +inline mmPixel24 operator * (mmReal const p_rS, mmPixel24 p_sP) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + + return p_sP; +} + +inline mmPixel24 operator / (mmPixel24 p_sP, mmReal const p_rS) { + p_sP.rR /= p_rS; + p_sP.rG /= p_rS; + p_sP.rB /= p_rS; + + return p_sP; +} + +inline mmPixel24 operator *= (mmPixel24 & p_sP, mmReal const p_rS) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + + return p_sP; +} + +inline mmPixel24 operator *= (mmReal const p_rS, mmPixel24 & p_sP) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + + return p_sP; +} + +inline mmPixel24 operator /= (mmPixel24 & p_sP, mmReal const p_rS) { + p_sP.rR /= p_rS; + p_sP.rG /= p_rS; + p_sP.rB /= p_rS; + + return p_sP; +} + +inline mmPixel32 operator + (mmPixel32 p_sP1, mmPixel32 const & p_sP2) { + p_sP1.rR += p_sP2.rR; + p_sP1.rG += p_sP2.rG; + p_sP1.rB += p_sP2.rB; + p_sP1.rA += p_sP2.rA; + + return p_sP1; +} + +inline mmPixel32 operator - (mmPixel32 p_sP1, mmPixel32 const & p_sP2) { + p_sP1.rR -= p_sP2.rR; + p_sP1.rG -= p_sP2.rG; + p_sP1.rB -= p_sP2.rB; + p_sP1.rA -= p_sP2.rA; + + return p_sP1; +} + +inline mmPixel32 operator += (mmPixel32 & p_sP1, mmPixel32 const & p_sP2) { + p_sP1.rR += p_sP2.rR; + p_sP1.rG += p_sP2.rG; + p_sP1.rB += p_sP2.rB; + p_sP1.rA += p_sP2.rA; + + return p_sP1; +} + +inline mmPixel32 operator -= (mmPixel32 & p_sP1, mmPixel32 const & p_sP2) { + p_sP1.rR -= p_sP2.rR; + p_sP1.rG -= p_sP2.rG; + p_sP1.rB -= p_sP2.rB; + p_sP1.rA -= p_sP2.rA; + + return p_sP1; +} + +inline mmPixel32 operator * (mmPixel32 p_sP, mmReal const p_rS) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + p_sP.rA *= p_rS; + + return p_sP; +} + +inline mmPixel32 operator * (mmReal const p_rS, mmPixel32 p_sP) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + p_sP.rA *= p_rS; + + return p_sP; +} + +inline mmPixel32 operator / (mmPixel32 p_sP, mmReal const p_rS) { + p_sP.rR /= p_rS; + p_sP.rG /= p_rS; + p_sP.rB /= p_rS; + p_sP.rA /= p_rS; + + return p_sP; +} + +inline mmPixel32 operator *= (mmPixel32 & p_sP, mmReal const p_rS) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + p_sP.rA *= p_rS; + + return p_sP; +} + +inline mmPixel32 operator *= (mmReal const p_rS, mmPixel32 & p_sP) { + p_sP.rR *= p_rS; + p_sP.rG *= p_rS; + p_sP.rB *= p_rS; + p_sP.rA *= p_rS; + + return p_sP; +} + +inline mmPixel32 operator /= (mmPixel32 & p_sP, mmReal const p_rS) { + p_sP.rR /= p_rS; + p_sP.rG /= p_rS; + p_sP.rB /= p_rS; + p_sP.rA /= p_rS; + + return p_sP; +} \ No newline at end of file diff --git a/proj/libcalc2d/src/mmStringUtilities.cpp b/proj/libcalc2d/src/mmStringUtilities.cpp new file mode 100644 index 0000000..71e22aa --- /dev/null +++ b/proj/libcalc2d/src/mmStringUtilities.cpp @@ -0,0 +1,376 @@ +#include + +#include + +#include + +mmString mmStringUtilities::BoolToString(bool p_bInput) +{ + if(p_bInput) + { + return mmString(L"true"); + }; + + return mmString(L"false"); +} + +mmString mmStringUtilities::MMIntToString(mmInt p_iInput, + mmInt p_iLength) +{ + wchar_t v_tcTemp[256]; + + if(p_iLength == 0) + { + swprintf(v_tcTemp,L"%d",p_iInput); + } + else + { + wchar_t v_tcTempFormat[16]; + + swprintf(v_tcTempFormat,L"%s0%dd",L"%",p_iLength); + swprintf(v_tcTemp,v_tcTempFormat,p_iInput); + }; + + return mmString(v_tcTemp); +} + +mmString mmStringUtilities::MMRealToString(mmReal p_rInput,mmInt p_iPrecision) +{ + wchar_t v_tcTemp[256]; + wchar_t v_tcTempFormat[16]; + + if(p_iPrecision >= 0) + { + swprintf(v_tcTempFormat,L"%s.%df",L"%",p_iPrecision); + } + else + { + swprintf(v_tcTempFormat,L"%sf",L"%"); + }; + + swprintf(v_tcTemp,v_tcTempFormat,p_rInput); + + return mmString(v_tcTemp); +} + +mmString mmStringUtilities::PointerToString(void* p_pInput) +{ + wchar_t v_tcTemp[256]; + + swprintf(v_tcTemp,L"%p",p_pInput); + + return mmString(v_tcTemp); +} + +mmInt mmStringUtilities::StringToMMInt(mmString p_sStr) +{ + int v_iTemp; + + swscanf(p_sStr.c_str(),L"%d",&v_iTemp); + + return v_iTemp; +} + +mmReal mmStringUtilities::StringToMMReal(mmString p_sStr) +{ + double v_rTemp; + + swscanf(p_sStr.c_str(),L"%lf",&v_rTemp); + + return v_rTemp; +} + +bool mmStringUtilities::StringToBool(mmString p_sStr) +{ + if( ( (p_sStr[0] == 't') || + (p_sStr[0] == 'T') ) && + ( (p_sStr[1] == 'r') || + (p_sStr[1] == 'R') ) && + ( (p_sStr[2] == 'u') || + (p_sStr[2] == 'U') ) && + ( (p_sStr[3] == 'e') || + (p_sStr[3] == 'E') ) ) + { + return true; + }; + + return false; +} + +/* +void mmStringUtilities::StringToUnsignedCharTable(std::string* p_psStr,unsigned char* p_psBuffer,mmInt* p_piReadCount) +{ + mmInt v_i = 0; + mmInt v_iActReadByte = 0; + mmInt v_iStringSize = static_cast(p_psStr->size()); + mmInt v_iLo,v_iHi; + + while(v_itm_year+1900, + v_psDateTimeStruc->tm_mon+1, + v_psDateTimeStruc->tm_mday, + v_psDateTimeStruc->tm_hour, + v_psDateTimeStruc->tm_min, + v_psDateTimeStruc->tm_sec); + + return mmString(v_tcTemp); +} + +mmString mmStringUtilities::MMIntToHHMMSSString(mmInt p_iInput) +{ + mmInt v_iHours = p_iInput/3600; + mmInt v_iMinutes = (p_iInput - v_iHours*3600)/60; + mmInt v_iSeconds = p_iInput - v_iHours*3600 - v_iMinutes*60; + + mmString v_sOutString = MMIntToString(v_iHours) + + mmString(L"h") + + MMIntToString(v_iMinutes,2) + + mmString(L"m") + + MMIntToString(v_iSeconds,2) + + mmString(L"s"); + + return v_sOutString; +} + +mmString mmStringUtilities::MMCharStringToMMString(const std::string p_sInputString) +{ + std::wostringstream v_sStream; + + const std::ctype& v_sCtfacet = std::use_facet< std::ctype >(v_sStream.getloc()); + + mmInt v_iCSize = p_sInputString.size(); + for(mmInt v_iC=0;v_iC& v_sCtfacet = std::use_facet< std::ctype >(v_sStream.getloc()); + + mmInt v_iCSize = p_sInputString.size(); + for(mmInt v_iC=0;v_iC mmStringUtilities::MMStringToVectorOfInt(const mmString p_sInputString) +{ + std::vector v_vOutVector; + + mmInt v_iInt,v_iStart,v_iStop; + mmInt v_iLen = p_sInputString.size(); + + v_iStart = 0; + v_iStop = -1; + while(v_iStop < v_iLen) + { + v_iStop++; + v_iStart = v_iStop; + while(v_iStop < v_iLen) + { + if(p_sInputString[v_iStop] != L' ') + { + v_iStop++; + } + else + { + break; + }; + }; + + if(v_iStop <= v_iLen) + { + mmString v_sTempInt = p_sInputString.substr(v_iStart,v_iStop-v_iStart); + + swscanf(v_sTempInt.c_str(),L"%d",&v_iInt); + v_vOutVector.push_back(v_iInt); + }; + }; + + return v_vOutVector; +} + +std::vector mmStringUtilities::MMStringToVectorOfMMString(const mmString p_sInputString) +{ + std::vector v_vOutVector; + + mmInt v_iStart,v_iStop; + mmInt v_iLen = p_sInputString.size(); + + v_iStart = 0; + v_iStop = -1; + while(v_iStop < v_iLen) + { + v_iStop++; + v_iStart = v_iStop; + while(v_iStop < v_iLen) + { + if(p_sInputString[v_iStop] != L' ') + { + v_iStop++; + } + else + { + break; + }; + }; + + if(v_iStop <= v_iLen) + { + v_vOutVector.push_back(p_sInputString.substr(v_iStart,v_iStop-v_iStart)); + }; + }; + + return v_vOutVector; +} + +mmString mmStringUtilities::MMStringToUpper(const mmString p_sInputString) +{ + mmString v_sOutString = p_sInputString; + + mmInt v_iCSize = p_sInputString.size(); + for(mmInt v_iC=0;v_iC +#include +//--------------------------------------------------------------------------- +mmXML::mmXMLNodePath::mmXMLNodePath( void ) { + Reset(); +} +//--------------------------------------------------------------------------- + +mmXML::mmXMLNodePath::mmXMLNodePath( mmString const & p_tPath ) { + AddString( p_tPath ); + Reset(); +} +//--------------------------------------------------------------------------- + +mmXML::mmXMLNodePath& mmXML::mmXMLNodePath::operator += ( mmString const & p_tPath ) { + if( ToString() == L"" ) + m_lsPath.clear(); + AddString( p_tPath ); + return *this; +} +//--------------------------------------------------------------------------- + +mmXML::mmXMLNodePath& mmXML::mmXMLNodePath::operator += ( mmXMLNodeID const & p_sNode ) { + m_lsPath.push_back( p_sNode ); + return *this; +} +//--------------------------------------------------------------------------- + +void mmXML::mmXMLNodePath::operator = ( mmString const & p_tPath ) { + m_lsPath.clear(); + AddString( p_tPath ); + Reset(); +} +//--------------------------------------------------------------------------- + +bool mmXML::mmXMLNodePath::operator == ( mmXMLNodePath const & p_sNodePath ) const { + return ( ToString() == p_sNodePath.ToString() ); +} +//--------------------------------------------------------------------------- + +mmXML::mmXMLNodePath::operator mmXMLNodeID() const { + return *m_lsiCurrent++; +} +//--------------------------------------------------------------------------- + +void mmXML::mmXMLNodePath::Reset( void ) const { + m_lsiCurrent = m_lsPath.begin(); +} +//--------------------------------------------------------------------------- + +bool mmXML::mmXMLNodePath::End( void ) const { + return ( m_lsiCurrent == m_lsPath.end() ); +} +//--------------------------------------------------------------------------- + +mmString mmXML::mmXMLNodePath::ToString( void ) const { + std::wstringstream v_sOutput; + std::list::const_iterator v_lsiLast = m_lsPath.end(); + v_lsiLast--; + for( std::list::const_iterator v_lsiI = m_lsPath.begin(); v_lsiI != m_lsPath.end(); ++v_lsiI ) { + v_sOutput << v_lsiI->tName; + if( v_lsiI->iIndex ) + v_sOutput << L"," << v_lsiI->iIndex; + if( v_lsiI != v_lsiLast ) + v_sOutput << L"/"; + } + return v_sOutput.str(); +} +//--------------------------------------------------------------------------- + +void mmXML::mmXMLNodePath::Reverse( void ) { + m_lsPath.reverse(); + Reset(); +} +//--------------------------------------------------------------------------- + +void mmXML::mmXMLNodePath::AddString( mmString const & p_usPath ) { + int v_iPosI; + mmXMLNodeID v_sNode; + + std::vector v_vcNodeNames; + Tokenize( p_usPath, L'/', v_vcNodeNames ); + for( std::vector::iterator v_vciI = v_vcNodeNames.begin(); v_vciI != v_vcNodeNames.end(); ++v_vciI ) { + if( ( v_iPosI = v_vciI->find_first_of( L"," ) ) > 0 ) { + v_sNode.iIndex = StringToMMInt( v_vciI->substr( v_iPosI+1 ) ); + v_sNode.tName = v_vciI->substr( 0, v_iPosI ); + } else { + v_sNode.iIndex = 0; + v_sNode.tName = *v_vciI; + } + m_lsPath.push_back( v_sNode ); + } +} +//--------------------------------------------------------------------------- + +void mmXML::mmXMLNodePath::Norm( void ) { + std::for_each( m_lsPath.begin(), m_lsPath.end(), MakeZero() ); +} +//--------------------------------------------------------------------------- + +bool mmXML::IsValidNodePosition( mmXMLNodePosition p_xNodePosition ) { + return ( p_xNodePosition.iGroupIndex >= 0 && p_xNodePosition.iLeafIndex >= 0 ); +} +//--------------------------------------------------------------------------- + +mmXML::mmXMLPositionedNode mmXML::CreateAutomation( mmXMLDocI * _p_xDoc, mmXMLAutoType p_eXMLAutoType ) { + mmXML::mmXMLNodeI * _v_xRootNode; + mmXML::mmXMLPositionedNode v_xPositionedRootNode; + + if( p_eXMLAutoType == mmXML::g_eXMLAutoInput ) + _p_xDoc->CreateXMLRootNode( mmImages::g_pAutoCalcXML_INParams_Node ); + else if( p_eXMLAutoType == mmXML::g_eXMLAutoOutput ) + _p_xDoc->CreateXMLRootNode( mmImages::g_pAutoCalcXML_OUTParams_Node ); + _v_xRootNode = _p_xDoc->GetXMLRootNode(); + v_xPositionedRootNode._v_xNode = _v_xRootNode; + v_xPositionedRootNode.sPosition.iGroupIndex = 0; + v_xPositionedRootNode.sPosition.iLeafIndex = 1; + + return v_xPositionedRootNode; +} +//---------------------------------------------------------------------------------- + +mmXML::mmXMLPositionedNode mmXML::CreateAutomationInput( mmXMLDocI * _p_xDoc ) { + return CreateAutomation( _p_xDoc, mmXML::g_eXMLAutoInput ); +} +//---------------------------------------------------------------------------------- + +mmXML::mmXMLPositionedNode mmXML::CreateAutomationOutput( mmXMLDocI * _p_xDoc ) { + return CreateAutomation( _p_xDoc, mmXML::g_eXMLAutoOutput ); +} +//---------------------------------------------------------------------------------- + +mmXML::mmXMLNodePosition mmXML::AddParam( mmXMLPositionedNode * _p_xPositionedRootNode, mmString p_tName, mmXMLDataType p_eType, void * _p_DefaultValue ) { + mmXML::mmXMLNodePosition v_xOutputP; + + v_xOutputP = AddParam( _p_xPositionedRootNode, p_tName, p_eType, mmXML::ConvertToString( p_eType, _p_DefaultValue ) ); + + return v_xOutputP; +} +//---------------------------------------------------------------------------------- + +mmXML::mmXMLNodePosition mmXML::AddParam( mmXML::mmXMLPositionedNode * _p_xPositionedRootNode, mmString p_tName, mmXML::mmXMLDataType p_eType, mmString p_tDefaultValue ) { + mmXML::mmXMLNodeI * _v_xParamNode, * _v_xNode, * _v_xRootNode; + mmXML::mmXMLNodePosition v_xParamPosition; + mmString v_tType; + + if( ( v_tType = GetTypeTransition( p_eType ) ) == L"" ) { + v_xParamPosition.iLeafIndex = -1; + v_xParamPosition.iGroupIndex = -1; + return v_xParamPosition; + } + + _v_xRootNode = _p_xPositionedRootNode->_v_xNode; + _v_xParamNode = _v_xRootNode->AddChild( mmImages::g_pAutoCalcXML_Params_Param_Node ); + _v_xNode = _v_xParamNode->AddChild( mmImages::g_pAutoCalcXML_Params_ParamName_Node ); + _v_xNode->SetText( p_tName ); + _v_xNode = _v_xParamNode->AddChild( mmImages::g_pAutoCalcXML_Params_ParamType_Node ); + _v_xNode->SetText( v_tType ); + _v_xNode = _v_xParamNode->AddChild( mmImages::g_pAutoCalcXML_Params_ParamValue_Node ); + _v_xNode->SetText( p_tDefaultValue ); + + v_xParamPosition.iLeafIndex = _p_xPositionedRootNode->sPosition.iGroupIndex++; + v_xParamPosition.iGroupIndex = 0; + + return v_xParamPosition; +} +//---------------------------------------------------------------------------------- + +void mmXML::UpdateOutputParam( mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams, mmXML::mmXMLNodePosition p_xNodePosition, void * _p_OutputValue ) { + mmXML::mmXMLNodeI * _v_xRootNode; + mmXML::mmXMLDocI * _v_xDoc; + mmString v_tOutputValue; + + _v_xDoc = mmInterfaceInitializers::CreateXMLDocument( NULL ); + _v_xDoc->ParseXMLBuffer( _p_sAutomationParams->sOutParams ); + _v_xRootNode = _v_xDoc->GetXMLRootNode(); + v_tOutputValue = mmXML::ConvertToString( mmXML::GetTypeTransition( _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamType_Node )->GetText() ), _p_OutputValue ); + _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamValue_Node )->SetText( v_tOutputValue ); + CopyOutputParams( _v_xDoc, _p_sAutomationParams ); + + delete _v_xDoc; +} +//---------------------------------------------------------------------------------- + +void mmXML::UpdateOutputParam( mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams, mmXML::mmXMLNodePosition p_xNodePosition, mmString p_tOutputValue ) { + mmXML::mmXMLNodeI * _v_xRootNode; + mmXML::mmXMLDocI * _v_xDoc; + + _v_xDoc = mmInterfaceInitializers::CreateXMLDocument( NULL ); + _v_xDoc->ParseXMLBuffer( _p_sAutomationParams->sOutParams ); + _v_xRootNode = _v_xDoc->GetXMLRootNode(); + _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamValue_Node )->SetText( p_tOutputValue ); + CopyOutputParams( _v_xDoc, _p_sAutomationParams ); + + delete _v_xDoc; +} +//---------------------------------------------------------------------------------- + +void mmXML::CopyInputParams( mmXML::mmXMLDocI * _p_xDoc, mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams ) { + mmString v_tInParams = _p_xDoc->SaveToXMLBuffer(); + mmInt v_iStrSize = v_tInParams.copy( _p_sAutomationParams->sInParams, INOUT_PARAMS_SIZE, 0 ); + _p_sAutomationParams->sInParams[ v_iStrSize ] = 0; +} +//---------------------------------------------------------------------------------- + +void mmXML::CopyOutputParams( mmXML::mmXMLDocI * _p_xDoc, mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams * _p_sAutomationParams ) { + mmString v_tOutParams = _p_xDoc->SaveToXMLBuffer(); + mmInt v_iStrSize = v_tOutParams.copy( _p_sAutomationParams->sOutParams, INOUT_PARAMS_SIZE, 0 ); + _p_sAutomationParams->sOutParams[ v_iStrSize ] = 0; +} +//---------------------------------------------------------------------------------- + +bool mmXML::SetValueByName( mmXML::mmXMLDocI * _p_xDoc, mmString p_tParamName, void * _p_InputPointer ) { + mmXML::mmXMLNodeI * _v_xRootNode, * _v_xGroupNode, * _v_sValueNode; + mmString v_tType, v_tValue, v_tTypeNodeName, v_tValueNodeName, v_tMainNodeName, v_tNameNodeName; + + _v_xRootNode = _p_xDoc->GetXMLRootNode(); + + _v_xGroupNode = _v_xRootNode; + v_tMainNodeName = mmImages::g_pAutoCalcXML_Params_Param_Node; + v_tTypeNodeName = mmImages::g_pAutoCalcXML_Params_ParamType_Node; + v_tValueNodeName = mmImages::g_pAutoCalcXML_Params_ParamValue_Node; + v_tNameNodeName = mmImages::g_pAutoCalcXML_Params_ParamName_Node; + + std::vector v_vcChildNodes = _v_xGroupNode->GetChilds(); + for( std::vector::iterator v_vciI = v_vcChildNodes.begin(); v_vciI != v_vcChildNodes.end(); ++v_vciI ) { + if( (*v_vciI)->FindChild( v_tNameNodeName )->GetText() == p_tParamName ) { + _v_sValueNode = (*v_vciI)->FindChild( v_tValueNodeName ); + v_tType = (*v_vciI)->FindChild( v_tTypeNodeName )->GetText(); + break; + } + } + if( _v_sValueNode == NULL ) + return false; + + _v_sValueNode->SetText( ConvertToString( GetTypeTransition( v_tType ), _p_InputPointer ) ); + + return true; +} +//---------------------------------------------------------------------------------- + +bool mmXML::SetValue( mmXML::mmXMLDocI * _p_xDoc, mmXML::mmXMLNodePosition p_xNodePosition, void * _p_InputPointer ) { + mmXML::mmXMLNodeI * _v_xRootNode, * _v_sNode; + mmString v_tType, v_tValue; + + if( ! IsValidNodePosition( p_xNodePosition ) ) + return false; + + _v_xRootNode = _p_xDoc->GetXMLRootNode(); + + _v_sNode = _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamValue_Node ); + v_tType = _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamType_Node )->GetText(); + + _v_sNode->SetText( ConvertToString( GetTypeTransition( v_tType ), _p_InputPointer ) ); + + return true; +} +//---------------------------------------------------------------------------------- + +bool mmXML::GetValueByName( mmXML::mmXMLDocI * _p_xDoc, mmString p_tParamName, void * _p_OutputPointer ) { + mmXML::mmXMLNodeI * _v_xRootNode=NULL, * _v_xGroupNode=NULL, * _v_sNode=NULL, * _v_sValueNode=NULL; + mmString v_tType, v_tValue, v_tTypeNodeName, v_tValueNodeName, v_tMainNodeName, v_tNameNodeName; + mmInt * _v_iOutput; + mmReal * _v_rOutput; + bool * _v_bOutput; + mmString * _v_tOutput; + + _v_xRootNode = _p_xDoc->GetXMLRootNode(); + _v_xGroupNode = _v_xRootNode; + + v_tMainNodeName = mmImages::g_pAutoCalcXML_Params_Param_Node; + v_tTypeNodeName = mmImages::g_pAutoCalcXML_Params_ParamType_Node; + v_tValueNodeName = mmImages::g_pAutoCalcXML_Params_ParamValue_Node; + v_tNameNodeName = mmImages::g_pAutoCalcXML_Params_ParamName_Node; + + std::vector v_vcChildNodes = _v_xGroupNode->GetChilds(); + for( std::vector::iterator v_vciI = v_vcChildNodes.begin(); v_vciI != v_vcChildNodes.end(); ++v_vciI ) { + if( ( _v_sNode = (*v_vciI)->FindChild( v_tNameNodeName ) ) != NULL && _v_sNode->GetText() == p_tParamName ) { + v_tValue = (*v_vciI)->FindChild( v_tValueNodeName )->GetText(); + if( (*v_vciI)->FindChild( L"ProperType" ) != NULL ) + v_tType = (*v_vciI)->FindChild( L"ProperType" )->GetText(); + else + v_tType = (*v_vciI)->FindChild( v_tTypeNodeName )->GetText(); + break; + } + } + + switch( GetTypeTransition( v_tType ) ) { + case g_eXMLReal: + _v_rOutput = static_cast( _p_OutputPointer ); + *_v_rOutput = mmStringUtilities::StringToMMReal( v_tValue ); + break; + case g_eXMLInt: + _v_iOutput = static_cast( _p_OutputPointer ); + *_v_iOutput = mmStringUtilities::StringToMMInt( v_tValue ); + break; + case g_eXMLString: + case g_eXMLImageName: + case g_eXMLDataLayerName: + _v_tOutput = static_cast( _p_OutputPointer ); + *_v_tOutput = v_tValue; + break; + case g_eXMLBool: + _v_bOutput = static_cast( _p_OutputPointer ); + *_v_bOutput = mmStringUtilities::StringToBool( v_tValue ); + break; + default: + return false; + } + + return true; +} +//---------------------------------------------------------------------------------- + +bool mmXML::GetValue( mmXML::mmXMLDocI * _p_xDoc, mmXML::mmXMLNodePosition p_xNodePosition, void * _p_OutputPointer ) { + mmXML::mmXMLNodeI * _v_xRootNode; + mmString v_tType, v_tValue; + mmInt * _v_iOutput; + mmReal * _v_rOutput; + bool * _v_bOutput; + mmString * _v_tOutput; + + if( ! IsValidNodePosition( p_xNodePosition ) ) + return false; + + _v_xRootNode = _p_xDoc->GetXMLRootNode(); + + v_tValue = _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamValue_Node )->GetText(); + v_tType = _v_xRootNode->GetChild( p_xNodePosition.iLeafIndex )->FindChild( mmImages::g_pAutoCalcXML_Params_ParamType_Node )->GetText(); + + switch( GetTypeTransition( v_tType ) ) { + case g_eXMLReal: + _v_rOutput = static_cast( _p_OutputPointer ); + *_v_rOutput = mmStringUtilities::StringToMMReal( v_tValue ); + break; + case g_eXMLInt: + _v_iOutput = static_cast( _p_OutputPointer ); + *_v_iOutput = mmStringUtilities::StringToMMInt( v_tValue ); + break; + case g_eXMLString: + case g_eXMLImageName: + case g_eXMLDataLayerName: + _v_tOutput = static_cast( _p_OutputPointer ); + *_v_tOutput = v_tValue; + break; + case g_eXMLBool: + _v_bOutput = static_cast( _p_OutputPointer ); + *_v_bOutput = mmStringUtilities::StringToBool( v_tValue ); + break; + default: + return false; + } + + return true; +} +//---------------------------------------------------------------------------------- + +mmXML::mmXMLDataType mmXML::GetTypeTransition( mmString p_tType ) { + if( p_tType.compare( mmImages::g_pAutoCalcXML_Params_ParamType_IntegerValue ) == 0 ) + return g_eXMLInt; + else if( p_tType.compare( mmImages::g_pAutoCalcXML_Params_ParamType_RealValue ) == 0 ) + return g_eXMLReal; + else if( p_tType.compare( mmImages::g_pAutoCalcXML_Params_ParamType_ImageName ) == 0 ) + return g_eXMLImageName; + else if( p_tType.compare( mmImages::g_pAutoCalcXML_Params_ParamType_DataLayerName ) == 0 ) + return g_eXMLDataLayerName; + else if( p_tType.compare( mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue ) == 0 ) + return g_eXMLBool; + else if( p_tType.compare( mmImages::g_pAutoCalcXML_Params_ParamType_String ) == 0 ) + return g_eXMLString; + return g_eXMLUnknownDataType; +} +//---------------------------------------------------------------------------------- + +mmString mmXML::GetTypeTransition( mmXML::mmXMLDataType p_eDataType ) { + switch( p_eDataType ) { + case mmXML::g_eXMLReal: + return mmImages::g_pAutoCalcXML_Params_ParamType_RealValue; + case mmXML::g_eXMLInt: + return mmImages::g_pAutoCalcXML_Params_ParamType_IntegerValue; + case mmXML::g_eXMLImageName: + return mmImages::g_pAutoCalcXML_Params_ParamType_ImageName; + case mmXML::g_eXMLDataLayerName: + return mmImages::g_pAutoCalcXML_Params_ParamType_DataLayerName; + case mmXML::g_eXMLBool: + return mmImages::g_pAutoCalcXML_Params_ParamType_BoolValue; + case mmXML::g_eXMLString: + return mmImages::g_pAutoCalcXML_Params_ParamType_String; + default: + return L""; + } +} +//---------------------------------------------------------------------------------- + +mmString mmXML::ConvertToString( mmXML::mmXMLDataType p_eType, void * _p_Data ) { + if( _p_Data != NULL ) + switch( p_eType ) { + case g_eXMLInt: + return mmStringUtilities::MMIntToString( *static_cast( _p_Data ) ); + case g_eXMLReal: + return mmStringUtilities::MMRealToString( *static_cast( _p_Data ) ); + case g_eXMLString: + case g_eXMLImageName: + case g_eXMLDataLayerName: + return *static_cast( _p_Data ); + case g_eXMLBool: + return mmStringUtilities::BoolToString( *static_cast( _p_Data ) ); + default: + return L""; + } + else + return L""; +} +//---------------------------------------------------------------------------------- + +mmXML::mmXMLNodeI* mmXML::GetNodeAt( mmXMLNodeI* _p_sRootNode, mmXMLNodePath const & p_sNodePath, bool p_bCreateNode ) { + mmXMLNodeI* _v_sXMLNode = _p_sRootNode, *_v_sTmpNode; + mmXMLNodePath::mmXMLNodeID v_sNode; + if( p_sNodePath.ToString() == L"" ) + return _p_sRootNode; + p_sNodePath.Reset(); + while( ! p_sNodePath.End() ) { + v_sNode = p_sNodePath; + if( ( _v_sTmpNode = _v_sXMLNode->FindChild( v_sNode.tName ) ) != NULL ) + _v_sXMLNode = _v_sTmpNode; + else + if( p_bCreateNode ) + _v_sXMLNode = _v_sXMLNode->AddChild( v_sNode.tName ); + else + return NULL; + + while( v_sNode.iIndex ) + if( ( _v_sTmpNode = _v_sXMLNode->GetNextSibling() ) != NULL ) + if( _v_sTmpNode->GetName() == v_sNode.tName ) { + _v_sXMLNode = _v_sTmpNode; + --v_sNode.iIndex; + } + else + if( p_bCreateNode ) + _v_sXMLNode = _v_sXMLNode->GetParent()->AddChild( v_sNode.tName ); + else + return NULL; + } + return _v_sXMLNode; +} +//--------------------------------------------------------------------------- + diff --git a/proj/libcalc2d/src/synchronize/mmSynchronizeWindowsImpl.cpp b/proj/libcalc2d/src/synchronize/mmSynchronizeWindowsImpl.cpp new file mode 100644 index 0000000..2d677ec --- /dev/null +++ b/proj/libcalc2d/src/synchronize/mmSynchronizeWindowsImpl.cpp @@ -0,0 +1,292 @@ +#include + +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmSynchronize::mmExclusiveLockCSWindows +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmSynchronize::mmExclusiveLockCSWindows::mmExclusiveLockCSWindows(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmSynchronize::mmExclusiveLockCSWindows",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + ::InitializeCriticalSectionAndSpinCount(&m_sCriticalSection, 300); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} + +mmSynchronize::mmExclusiveLockCSWindows::~mmExclusiveLockCSWindows() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + if(m_sCriticalSection.LockCount > -1) + { + SendLogMessage(mmLog::critical,mmString(L"Destructor Locked")); + + throw mmError(mmeExclusiveLockLocked); + }; + + ::DeleteCriticalSection(&m_sCriticalSection); + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +bool mmSynchronize::mmExclusiveLockCSWindows::TryLock(void) +{ + bool v_bIsLocked = true; + + SendLogMessage(mmLog::debug,mmString(L"Start TryLock")); + + if(::TryEnterCriticalSection(&m_sCriticalSection) == 0) + { + v_bIsLocked = false; + }; + + SendLogMessage(mmLog::debug,mmString(L"End TryLock Locked=") + mmStringUtilities::BoolToString(v_bIsLocked)); + + return v_bIsLocked; +} + +void mmSynchronize::mmExclusiveLockCSWindows::Lock(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Lock")); + + ::EnterCriticalSection(&m_sCriticalSection); + + SendLogMessage(mmLog::debug,mmString(L"End Lock")); +} + +void mmSynchronize::mmExclusiveLockCSWindows::Unlock(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Unlock")); + + ::LeaveCriticalSection(&m_sCriticalSection); + + SendLogMessage(mmLog::debug,mmString(L"End Unlock")); +} + + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmSynchronize::mmReadWriteLockCSWindows +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmSynchronize::mmReadWriteLockCSWindows::mmReadWriteLockCSWindows(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmSynchronize::mmReadWriteLockCSWindows",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + try + { + m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(p_psLogReceiver); + } + catch(mmError &v_sErr) + { + if(v_sErr.GetErrorCode() == mmeBadAlloc) + { + SendLogMessage(mmLog::critical,mmString(L"Constructor ErrorAllocationMemory")); + }; + + throw; + }; + + m_iReadWriteCount = 0; + m_bWaitForWriteLock = false; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor PtrToExclusiveLock=") + mmStringUtilities::PointerToString(m_psExclusiveLock)); +} + +mmSynchronize::mmReadWriteLockCSWindows::~mmReadWriteLockCSWindows() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + delete m_psExclusiveLock; + + if(m_iReadWriteCount != 0) + { + SendLogMessage(mmLog::critical,mmString(L"Destructor BadEndConditions RWCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount)); + + throw mmError(mmeReadWriteLockBadEndLockCount); + }; + if(m_bWaitForWriteLock) + { + SendLogMessage(mmLog::critical,mmString(L"Destructor BadEndConditions WaitForWrite=") + + mmStringUtilities::BoolToString(m_bWaitForWriteLock)); + + throw mmError(mmeReadWriteLockWaitForWrite); + }; + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +bool mmSynchronize::mmReadWriteLockCSWindows::TryLockForRead(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start TryLockForRead")); + + bool v_bIsLocked = false; + + m_psExclusiveLock->Lock(); + if( (m_iReadWriteCount >= 0) && (!m_bWaitForWriteLock) ) + { + m_iReadWriteCount++; + v_bIsLocked = true; + }; + m_psExclusiveLock->Unlock(); + + SendLogMessage(mmLog::debug,mmString(L"End TryLockForRead LockCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount) + + mmString(L" Locked=") + + mmStringUtilities::BoolToString(v_bIsLocked)); + + return v_bIsLocked; +} + +void mmSynchronize::mmReadWriteLockCSWindows::LockForRead(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start LockForRead")); + + bool v_bIsLocked = false; + + while(!v_bIsLocked) + { + if(TryLockForRead()) + { + v_bIsLocked = true; + } + else + { + Sleep(1); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End LockForRead LockCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount)); +} + +void mmSynchronize::mmReadWriteLockCSWindows::UnlockFromRead(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UnlockFromRead")); + + bool v_bIsReadWriteLockDeSynchronized = false; + + m_psExclusiveLock->Lock(); + if(m_iReadWriteCount > 0) + { + m_iReadWriteCount--; + } + else + { + v_bIsReadWriteLockDeSynchronized = true; + }; + m_psExclusiveLock->Unlock(); + + if(v_bIsReadWriteLockDeSynchronized) + { + SendLogMessage(mmLog::critical,mmString(L"UnlockFromRead TooManyUnlocksFromRead")); + + throw mmError(mmeReadWriteLockReadUnlocked); + }; + + SendLogMessage(mmLog::debug,mmString(L"End UnlockFromRead LockCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount)); +} + +bool mmSynchronize::mmReadWriteLockCSWindows::TryLockForWrite(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start TryLockForWrite")); + + bool v_bIsLocked = false; + + m_psExclusiveLock->Lock(); + if(m_iReadWriteCount == 0) + { + m_iReadWriteCount = -1; + v_bIsLocked = true; + }; + m_psExclusiveLock->Unlock(); + + SendLogMessage(mmLog::debug,mmString(L"End TryLockForWrite LockCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount) + + mmString(L" Locked=") + + mmStringUtilities::BoolToString(v_bIsLocked)); + + return v_bIsLocked; +} + +void mmSynchronize::mmReadWriteLockCSWindows::LockForWrite(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start LockForWrite")); + + bool v_bIsLocked = false; + + while(!v_bIsLocked) + { + m_psExclusiveLock->Lock(); + if(m_iReadWriteCount == 0) + { + m_iReadWriteCount = -1; + v_bIsLocked = true; + } + else + { + if( (m_iReadWriteCount > 0) && (!m_bWaitForWriteLock) ) + { + m_bWaitForWriteLock = true; + }; + }; + m_psExclusiveLock->Unlock(); + + if(!v_bIsLocked) + { + Sleep(1); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End LockForWrite LockCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount)); +} + +void mmSynchronize::mmReadWriteLockCSWindows::UnlockFromWrite(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start UnlockFromWrite")); + + bool v_bIsReadWriteLockDeSynchronized = false; + + m_psExclusiveLock->Lock(); + if(m_iReadWriteCount == -1) + { + m_iReadWriteCount = 0; + m_bWaitForWriteLock = false; + } + else + { + v_bIsReadWriteLockDeSynchronized = true; + }; + m_psExclusiveLock->Unlock(); + + if(v_bIsReadWriteLockDeSynchronized) + { + SendLogMessage(mmLog::critical,mmString(L"UnlockFromWrite TooManyUnlocksFromWrite")); + + throw mmError(mmeReadWriteLockWriteUnlocked); + }; + + SendLogMessage(mmLog::debug,mmString(L"End UnlockFromWrite LockCount=") + + mmStringUtilities::MMIntToString(m_iReadWriteCount)); +} + +mmInt mmSynchronize::mmReadWriteLockCSWindows::GetLockState(bool* p_pbWaitForWrite) +{ + SendLogMessage(mmLog::debug,mmString(L"Start GetLockState")); + + mmInt v_iLockState = m_iReadWriteCount; + *p_pbWaitForWrite = m_bWaitForWriteLock; + + this->SendLogMessage(mmLog::debug,mmString(L"End GetLockState")); + + return v_iLockState; +} diff --git a/proj/libcalc2d/src/thread/mmThreadWindowsImpl.cpp b/proj/libcalc2d/src/thread/mmThreadWindowsImpl.cpp new file mode 100644 index 0000000..a2313fc --- /dev/null +++ b/proj/libcalc2d/src/thread/mmThreadWindowsImpl.cpp @@ -0,0 +1,310 @@ +#include + +#include + +#include +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmThreads::mmThreadWindows +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +mmThread::mmThreadWindows::mmThreadWindows(mmLog::mmLogReceiverI *p_psLogReceiver): + mmLog::mmLogSender(L"mmThread::mmThreadWindows",p_psLogReceiver) +{ + mmInt v_iTemp; + + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + try + { + //m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(p_psLogReceiver); + m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(NULL); + } + catch(mmError &v_sErr) + { + if(v_sErr.GetErrorCode() == mmeBadAlloc) + { + SendLogMessage(mmLog::critical,mmString(L"Constructor ErrorAllocationMemory")); + }; + + throw v_sErr; + }; + + m_hWinThreadHandle = CreateThread(NULL,0,ThreadRedirectFunction,this,CREATE_SUSPENDED,reinterpret_cast(&v_iTemp)); + //SetThreadPriority(m_hWinThreadHandle,THREAD_PRIORITY_HIGHEST); + + // jeśli utworzenie nowego wątka się nie powiedzie + if(m_hWinThreadHandle == NULL) + { + delete m_psExclusiveLock; + + SendLogMessage(mmLog::critical,mmString(L"Constructor CreationThreadError")); + + throw mmError(mmeThreadCreateThreadError); + }; + + m_eThreadStatus = created; + SendLogMessage(mmLog::debug,mmString(L"Constructor Status=created")); + + m_psThreadExecutionClass = NULL; + + SendLogMessage(mmLog::debug,mmString(L"End Constructor PtrToExclusiveLock=") + + mmStringUtilities::PointerToString(m_psExclusiveLock) + + mmString(L"; ThreadID=") + + mmStringUtilities::MMIntToString(v_iTemp)); +} + +mmThread::mmThreadWindows::~mmThreadWindows() +{ + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + // zatrzymuję wątek + this->Stop(); + + if(WaitForSingleObject(m_hWinThreadHandle,INFINITE) != WAIT_OBJECT_0) + { + SendLogMessage(mmLog::critical,mmString(L"Destructor BadStateOfThread")); + }; + + CloseHandle(m_hWinThreadHandle); + + delete m_psExclusiveLock; + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +DWORD WINAPI mmThread::mmThreadWindows::ThreadRedirectFunction(LPVOID p_pThreadClassPointer) +{ + mmThread::mmThreadWindows* v_pThreadWindows = reinterpret_cast(p_pThreadClassPointer); + + v_pThreadWindows->ThreadExecute(); + + return 0; +} + +void mmThread::mmThreadWindows::ThreadExecute(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start ThreadExecute")); + + + CoInitializeEx(NULL,COINIT_MULTITHREADED); + bool v_bIsCalculated = m_psThreadExecutionClass->Execute(); + CoUninitialize(); + + m_psExclusiveLock->Lock(); + if(v_bIsCalculated) + { + m_eThreadStatus = finished; + SendLogMessage(mmLog::debug,mmString(L"ThreadExecute Status=finished")); + } + else + { + m_eThreadStatus = stopped; + SendLogMessage(mmLog::debug,mmString(L"ThreadExecute Status=stopped")); + }; + + // to wywołanie jest w sekcji krytycznej dlatego, że często po tej metodzie + // wywołuje się destruktora i wtedy to wywołanie jest już w nie istniejącym + // obiekcie + SendLogMessage(mmLog::debug,mmString(L"End ThreadExecute")); + + m_psExclusiveLock->Unlock(); +} + +void mmThread::mmThreadWindows::RegisterThreadExecutionClass(mmThreadExecutionI* p_psThreadExecutionClass) +{ + SendLogMessage(mmLog::debug,mmString(L"Start RegisterThreadExecutionClass")); + + m_psExclusiveLock->Lock(); + try + { + if( (m_eThreadStatus == created) || (m_eThreadStatus == initialized) ) + { + m_psThreadExecutionClass = p_psThreadExecutionClass; + if(m_eThreadStatus != initialized) + { + m_eThreadStatus = initialized; + SendLogMessage(mmLog::debug,mmString(L"RegisterThreadExecutionClass Status=initialized")); + }; + + SendLogMessage(mmLog::debug,mmString(L"RegisterThreadExecutionClass Registered PtrToExecutionObject=") + + mmStringUtilities::PointerToString(m_psThreadExecutionClass)); + } + else + { + SendLogMessage(mmLog::critical,mmString(L"RegisterThreadExecutionClass CantRegister")); + + throw mmError(mmeThreadCantRegisterExecutionClass); + }; + } + catch(mmError &v_sErr) + { + m_psExclusiveLock->Unlock(); + + throw v_sErr; + }; + + m_psExclusiveLock->Unlock(); + + SendLogMessage(mmLog::debug,mmString(L"End RegisterThreadExecutionClass")); +} + +void mmThread::mmThreadWindows::Run(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Run")); + + m_psExclusiveLock->Lock(); + try + { + // tylko kiedy wątek jest w stanie initialized może być wywoływana metoda Run + if(this->m_eThreadStatus == initialized) + { + if(ResumeThread(m_hWinThreadHandle) == 1) + { + m_eThreadStatus = running; + SendLogMessage(mmLog::debug,mmString(L"Run Status=running")); + } + else + { + SendLogMessage(mmLog::critical,mmString(L"Run ResumeThreadError")); + + throw mmError(mmeThreadResumeError); + }; + } + else + { + SendLogMessage(mmLog::critical,mmString(L"Run BadThreadStateError")); + + throw mmError(mmeThreadBadThreadState); + }; + } + catch(mmError &v_sErr) + { + m_psExclusiveLock->Unlock(); + + throw v_sErr; + }; + + m_psExclusiveLock->Unlock(); + + SendLogMessage(mmLog::debug,mmString(L"End Run")); +} + +void mmThread::mmThreadWindows::Stop(void) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Stop")); + + bool bIsCreatedInitializedStoppedOrFinished = false; + + while(!bIsCreatedInitializedStoppedOrFinished) + { + m_psExclusiveLock->Lock(); + // w przypadku: kiedy jest uruchomiony ale nie wiadomo czy już liczy + if(m_eThreadStatus == running) + { + if(m_psThreadExecutionClass->IsExecuting()) + { + m_eThreadStatus = stopping; + SendLogMessage(mmLog::debug,mmString(L"Stop Status=stopping")); + + // informuję o zatrzymaniu wątka klasę liczącą + m_psThreadExecutionClass->StopExecution(); + }; + } + else + { + // w innych + if(m_eThreadStatus != stopping) + { + bIsCreatedInitializedStoppedOrFinished = true; + }; + }; + m_psExclusiveLock->Unlock(); + + if(!bIsCreatedInitializedStoppedOrFinished) + { + Sleep(1); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End Stop")); +} + +mmThread::mmThreadI::eStatus mmThread::mmThreadWindows::GetStatus(void) +{ +// SendLogMessage(mmLog::debug,mmString(L"Start GetStatus")); + + eStatus v_eTempStat; + + m_psExclusiveLock->Lock(); + v_eTempStat = m_eThreadStatus; + m_psExclusiveLock->Unlock(); + + mmString v_sStatusString; + + switch(v_eTempStat) + { + case created: + { + v_sStatusString = L"created"; + }; + break; + case initialized: + { + v_sStatusString = L"initialized"; + }; + break; + case running: + { + v_sStatusString = L"running"; + }; + break; + case stopping: + { + v_sStatusString = L"stopping"; + }; + break; + case stopped: + { + v_sStatusString = L"stopped"; + }; + break; + case finished: + { + v_sStatusString = L"finished"; + }; + break; + default: + { + SendLogMessage(mmLog::critical,mmString(L"GetStatus UnknownThreadState")); + + throw mmError(mmeThreadUnknownThreadState); + }; + }; + + SendLogMessage(mmLog::debug,mmString(L"End GetStatus Status=")+ + v_sStatusString); + + return v_eTempStat; +} + +mmReal mmThread::mmThreadWindows::GetProgress(void) +{ + mmReal v_rProgress = -1.0; + + SendLogMessage(mmLog::debug,mmString(L"Start GetProgress")); + + m_psExclusiveLock->Lock(); + if(m_eThreadStatus == running) + { + v_rProgress = m_psThreadExecutionClass->GetProgress(); + }; + m_psExclusiveLock->Unlock(); + + SendLogMessage(mmLog::debug,mmString(L"End GetProgress")); + + return v_rProgress; +} diff --git a/proj/libcalc2d/src/windows/mmDllSupport.cpp b/proj/libcalc2d/src/windows/mmDllSupport.cpp new file mode 100644 index 0000000..0c773c1 --- /dev/null +++ b/proj/libcalc2d/src/windows/mmDllSupport.cpp @@ -0,0 +1,59 @@ +#include + +#include +#include +#pragma comment ( lib, "Imagehlp.lib" ) + +#include + + +mmString mmDLLSupport::FindSymbolInDLLExportTable(mmString p_sDLLName, + mmString p_sName) +{ + mmString v_sFullSymbol; + + LOADED_IMAGE v_sLoadedImage; + + std::string v_sCharStringDllName = mmStringUtilities::MMStringToCharString(p_sDLLName); + std::string v_sCharStringName = mmStringUtilities::MMStringToCharString(p_sName); + + if(MapAndLoad(const_cast(v_sCharStringDllName.c_str()), + "", + &v_sLoadedImage, + TRUE, + TRUE)) + { + PIMAGE_EXPORT_DIRECTORY v_sExpDir; + v_sExpDir = (PIMAGE_EXPORT_DIRECTORY)(v_sLoadedImage.FileHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress); + if(v_sExpDir != NULL) + { + v_sExpDir = (PIMAGE_EXPORT_DIRECTORY)ImageRvaToVa(v_sLoadedImage.FileHeader, v_sLoadedImage.MappedAddress, (DWORD)v_sExpDir, 0); + + //PDWORD* v_pExpNames = (PDWORD *)ImageRvaToVa(v_sLoadedImage.FileHeader, v_sLoadedImage.MappedAddress, v_sExpDir->AddressOfNames, 0); + PDWORD v_pExpNames = (PDWORD )ImageRvaToVa(v_sLoadedImage.FileHeader, v_sLoadedImage.MappedAddress, v_sExpDir->AddressOfNames, 0); + + mmInt v_iTemp; + mmInt v_iExportSymbolCount = v_sExpDir->NumberOfNames; + for (v_iTemp=0;v_iTemp +//#endif +// uwaga - StdAfx jest specyficzny dla visuala. Po jego załączeniu nie można dać #endif zamykającego #ifndef MADMAC + +// uwaga2 - zdefiniowanie MADMAC odblokowuje logowanie i rzucanie wyjatkow +#define MADMAC +#include + +#ifndef RELEASE_PTR +#define RELEASE_PTR(x) \ + if( x != NULL ) \ + { \ + x.Release(); \ + x = NULL; \ + } +#endif + + + +#ifdef MADMAC +#include +#include +#endif +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmXML::mmXMLNodeBB +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + +int Is_MSXML_Node(MSXML2::IXMLDOMNodePtr pChild) +{ + + MSXML2::tagDOMNodeType v_i = ( pChild->nodeType); + // I handle only few node type other are ignored and are considered as NODE_ELEMENT + // + // Handled Node type by this wrapper: + // - NODE_ELEMENT + // - NODE_TEXT + // - NODE_CDATA_SECTION + // - NODE_PROCESSING_INSTRUCTION + + // if(pChild->nodeType == MSXML2::NODE_TEXT) return MSXML2::NODE_TEXT; + // if(pChild->nodeType == MSXML2::NODE_CDATA_SECTION) return MSXML2::NODE_CDATA_SECTION; + // if(pChild->nodeType == MSXML2::NODE_PROCESSING_INSTRUCTION ) return MSXML2::NODE_PROCESSING_INSTRUCTION; + //return HRESULT( pChild->nodeType); + // return MSXML2::NODE_ELEMENT; + return v_i; +} + +#ifdef MADMAC +mmXML::mmXMLNodeBB::mmXMLNodeBB( mmLog::mmLogReceiverI* p_psLogReceiver): +mmLog::mmLogSender(L"mmXML::mmXMLNodeBB",p_psLogReceiver) +{ + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); + + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +} +#else +mmXML::mmXMLNodeBB::mmXMLNodeBB( ) +{ + +} +#endif + +mmXML::mmXMLNodeBB::~mmXMLNodeBB() +{ + //SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); + + RemoveAllChilds(); + + //SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +} + +mmString mmXML::mmXMLNodeBB::GetName(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start GetName")); + + SendLogMessage(mmLog::debug,mmString(L"End GetName Name=") + + m_sNodeName); +#endif + return m_sNodeName; +} + +void mmXML::mmXMLNodeBB::SetName(mmString p_sName) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start SetName") + + m_sNodeName); +#endif + m_sNodeName = p_sName; +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End SetName")); +#endif +} + +bool mmXML::mmXMLNodeBB::IsLeaf(void) +{ + bool v_bIsLeaf = true; +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start IsLeaf")); +#endif + if(m_sChilds.size() != 0) + { + v_bIsLeaf = false; + }; + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End IsLeaf Result=") + + mmStringUtilities::BoolToString(v_bIsLeaf)); +#endif + + return v_bIsLeaf; +} + +std::vector mmXML::mmXMLNodeBB::GetAttributes(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start GetAttributes")); + + SendLogMessage(mmLog::debug,mmString(L"End GetAttributes")); +#endif + return m_sAttributes; +} + +void mmXML::mmXMLNodeBB::AddAttribute(mmString p_sAttrName, + mmString p_sAttrValue) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start AddAttribute Name=") + + p_sAttrName + + mmString(L" Value=") + + p_sAttrValue); +#endif + mmXML::sXMLAttribute v_sAttr; + + v_sAttr.sName = p_sAttrName; + v_sAttr.sValue = p_sAttrValue; + + m_sAttributes.push_back(v_sAttr); + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End AddAttribute")); +#endif +} + +#ifdef MADMAC +void mmXML::mmXMLNodeBB::RemoveAttribute(mmString p_sAttrName) +#else +bool mmXML::mmXMLNodeBB::RemoveAttribute(mmString p_sAttrName) +#endif +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start RemoveAttribute Name=") + + p_sAttrName); +#endif; + + mmInt v_i,v_iAttrCount,v_iRemovedCount; + std::vector v_sNewAttributes; + + v_iRemovedCount = 0; + v_iAttrCount = static_cast(m_sAttributes.size()); + for(v_i=0;v_i mmXML::mmXMLNodeBB::GetChilds(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start GetChilds")); + + SendLogMessage(mmLog::debug,mmString(L"End GetChilds")); +#endif + return m_sChilds; +} + +mmXML::mmXMLNodeI* mmXML::mmXMLNodeBB::AddChild(mmString p_sChildName) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start AddChild Name=") + + p_sChildName); + + mmXMLNodeBB* v_psNode = new mmXML::mmXMLNodeBB(GetLogReceiver()); +#else + mmXMLNodeBB* v_psNode = new mmXML::mmXMLNodeBB(); +#endif + + v_psNode->m_sNodeName = p_sChildName; + v_psNode->m_psParent = this; + m_sChilds.push_back(v_psNode); + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End AddChild")); +#endif + return v_psNode; +} + +void mmXML::mmXMLNodeBB::AddChildWithStructure(mmXMLNodeI* p_psChildNode) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start AddChildWithStructure")); + mmXMLNodeBB* v_psNode = new mmXML::mmXMLNodeBB(GetLogReceiver()); +#else + mmXMLNodeBB* v_psNode = new mmXML::mmXMLNodeBB(); +#endif + + v_psNode->m_psParent = p_psChildNode->GetParent(); + v_psNode->m_sNodeName = p_psChildNode->GetName(); + v_psNode->m_sNodeValue = p_psChildNode->GetText(); + v_psNode->m_sAttributes = p_psChildNode->GetAttributes(); + + std::vector v_vChilds = p_psChildNode->GetChilds(); + mmInt v_iChildsCount = v_vChilds.size(); + for(mmInt v_iC=0;v_iCAddChildWithStructure(v_vChilds[v_iC]); + }; + + m_sChilds.push_back(v_psNode); +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End AddChildWithStructure")); +#endif +} + +mmXML::mmXMLNodeI* mmXML::mmXMLNodeBB::FindChild(mmString p_sChildName) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start FindChild Name=")+ + p_sChildName); +#endif + + mmInt v_i,v_iChildCount; + mmXML::mmXMLNodeI* v_psFoundNode = NULL; + + v_iChildCount = static_cast(m_sChilds.size()); + for(v_i=0;v_iGetName().compare(p_sChildName) == 0) +#else + if(m_sChilds[v_i]->GetName().compare(p_sChildName) == 0) +#endif + { + v_psFoundNode = m_sChilds[v_i]; + break; + }; + }; +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End FindChild")); +#endif + return v_psFoundNode; +} + +mmXML::mmXMLNodeI* mmXML::mmXMLNodeBB::FindNextChild(mmXML::mmXMLNodeI* p_psCurrentChild, mmString p_sChildName) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start FindChild Name=")+ + p_sChildName); +#endif + + mmInt v_i,v_iChildCount; + mmXML::mmXMLNodeI* v_psFoundNode = NULL; + + v_iChildCount = static_cast(m_sChilds.size()); + bool v_bCurrentNodeFound = false; + + for(v_i=0;v_iGetName().compare(p_sChildName) == 0) +#else + if(m_sChilds[v_i]->GetName().compare(p_sChildName) == 0) +#endif + { + if (( v_bCurrentNodeFound == true) ) + { + v_psFoundNode = m_sChilds[v_i]; + break; + } + if ( (p_psCurrentChild == m_sChilds[ v_i ] ) && ( v_bCurrentNodeFound == false) ) + v_bCurrentNodeFound = true; + + }; + }; +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End FindChild")); +#endif + return v_psFoundNode; +} + +#ifdef MADMAC +mmXML::mmXMLNodeI* mmXML::mmXMLNodeBB::GetChild(mmInt p_iChildIndex) +#else +mmXML::mmXMLNodeI* mmXML::mmXMLNodeBB::GetChild(mmInt p_iChildIndex) +#endif +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start GetChild")); +#endif + + mmInt v_i,v_iChildCount; + mmXML::mmXMLNodeI* v_psFoundNode = NULL; + + v_iChildCount = static_cast(m_sChilds.size()); + for(v_i=0;v_i v_sNewChilds; + + v_iChildCount = static_cast(m_sChilds.size()); + for(v_i=0;v_i(m_sChilds.size()); + for(v_i=0;v_i v_sChildNodes = m_psParent->GetChilds(); + mmXML::mmXMLNodeI* v_psNode = NULL; + for( std::vector::iterator v_sI = v_sChildNodes.begin(); v_sI != v_sChildNodes.end()-1; ++v_sI ) { + if( *v_sI == static_cast(this) ) { + v_psNode = *(v_sI+1); + break; + } + } +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End GetNextSibling")); +#endif + return v_psNode; +} + +mmXML::mmXMLNodeI* mmXML::mmXMLNodeBB::GetPrevSibling( void ) { +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End GetPrevSibling")); +#endif + if( m_psParent == NULL ) + return NULL; + std::vector v_sChildNodes = m_psParent->GetChilds(); + mmXML::mmXMLNodeI* v_psNode = NULL; + for( std::vector::iterator v_sI = v_sChildNodes.begin()+1; v_sI != v_sChildNodes.end(); ++v_sI ) { + if( *v_sI == static_cast(this) ) { + v_psNode = *(v_sI-1); + break; + } + } +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End GetPrevSibling")); +#endif + return v_psNode; +} + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +//// mmXML::mmXMLDocBB +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +#ifdef MADMAC +mmXML::mmXMLDocBB::mmXMLDocBB(mmLog::mmLogReceiverI *p_psLogReceiver): +mmLog::mmLogSender(L"mmXML::mmXMLBB",p_psLogReceiver) +#else +mmXML::mmXMLDocBB::mmXMLDocBB() +#endif +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start Constructor")); +#endif + //CoInitializeEx(NULL,COINIT_APARTMENTTHREADED); + m_bOLEInitialized = false; + InitializeXML(); +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End Constructor")); +#endif +} + +mmXML::mmXMLDocBB::~mmXMLDocBB() +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start Destructor")); +#endif + + this->Reset_XML_Document(); + m_psXMLBBDoc.Release(); + CoUninitialize(); +#ifdef MADMAC + + + SendLogMessage(mmLog::debug,mmString(L"End Destructor")); +#endif +} + +#ifdef MADMAC +void mmXML::mmXMLDocBB::ParseXMLFile(mmString p_sXMLFileName) +#else +bool mmXML::mmXMLDocBB::ParseXMLFile(mmString p_sXMLFileName) +#endif +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start ParseXMLFile File=") + + p_sXMLFileName); +#endif + // delete XML structure + m_sRootNode.RemoveAllChilds(); + m_sRootNode.RemoveAllAttributes(); + + // load XMLDocument + + if (Load_XML_Document(p_sXMLFileName) == false) + +#ifdef MADMAC + { + + SendLogMessage(mmLog::critical,mmString(L"ParseXMLFile Error") ); + + throw mmError(mmeXMLParseError); + + }; +#else + + + return false; +#endif + + // refresh XML structure from XMLDocument + LoadNodeStructureFromXMLDocument(); +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End ParseXMLFile")); +#else + return true; +#endif +} +#ifdef MADMAC +void mmXML::mmXMLDocBB::ParseXMLBuffer(mmString p_sXMLBuffer) +#else +bool mmXML::mmXMLDocBB::ParseXMLBuffer(mmString p_sXMLBuffer) +#endif +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start ParseXMLBuffer")); +#endif + // delete XML structure + m_sRootNode.RemoveAllChilds(); + m_sRootNode.RemoveAllAttributes(); + + // load XMLDocument + try + { + this->Load_XML_From_Buffer(p_sXMLBuffer); + } +#ifdef MADMAC + catch(...) + { + SendLogMessage(mmLog::critical,mmString(L"ParseXMLFile Error")); + + throw mmError(mmeXMLParseError); + + } +#else + catch(...) + { + + return false; + + + }; +#endif + // refresh XML structure from XMLDocument + LoadNodeStructureFromXMLDocument(); +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End ParseXMLBuffer")); +#else + return true; +#endif +} + +#ifdef MADMAC +void mmXML::mmXMLDocBB::SaveToXMLFile(mmString p_sXMLFileName) +#else +bool mmXML::mmXMLDocBB::SaveToXMLFile(mmString p_sXMLFileName) +#endif +{ + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start SaveToXMLFile File=") + + p_sXMLFileName); +#endif + + // save XML structure into XMLDocument + SaveNodeStructureIntoXMLDocument(); + + // using XMLDocument API + mmString v_sOutString = GetXMLFormattedString(); + + // opening TXT file +#ifdef MADMAC + mmFileIO::mmTextFileWriteI* v_psTxtFile = mmInterfaceInitializers::CreateTextFileForWrite(this->GetLogReceiver()); + v_psTxtFile->Open(p_sXMLFileName,mmFileIO::trunc_for_write); + v_psTxtFile->WriteLine(v_sOutString); + delete v_psTxtFile; +#else + m_psXMLBBDoc->save( _bstr_t( p_sXMLFileName.c_str() ) ); +#endif +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End SaveToXMLFile")); +#else + return true; +#endif +} + +mmString mmXML::mmXMLDocBB::SaveToXMLBuffer(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start SaveToXMLBuffer")); +#endif + // save XML structure into XMLDocument + SaveNodeStructureIntoXMLDocument(); + + // using XMLDocument API + mmString v_sOutString = GetXMLFormattedString(); +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End SaveToXMLBuffer")); +#endif + return v_sOutString; +} + +bool mmXML::mmXMLDocBB::IsXMLStructureValid(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start IsXMLStructureValid")); +#endif + bool v_bIsValid = true; + // TODO: validate XML structure + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End IsXMLStructureValid")); +#endif + return v_bIsValid; +} + +#ifdef MADMAC +mmXML::mmXMLNodeI* mmXML::mmXMLDocBB::GetXMLRootNode(void) +#else +mmXML::mmXMLNodeI* mmXML::mmXMLDocBB::GetXMLRootNode( void ) +#endif +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start GetXMLRootNode")); + + SendLogMessage(mmLog::debug,mmString(L"End GetXMLRootNode")); +#endif; + return &m_sRootNode; +} + +void mmXML::mmXMLDocBB::CreateXMLRootNode(mmString p_sRootNodeName) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start CreateXMLRootNode NodeName=") + + p_sRootNodeName); +#endif + m_sRootNode.RemoveAllChilds(); + m_sRootNode.RemoveAllAttributes(); + m_sRootNode.SetName(p_sRootNodeName); + m_sRootNode.SetText(mmString(L"")); + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End CreateXMLRootNode")); +#endif +} + +void mmXML::mmXMLDocBB::CopyXMLRootNodeStructure(mmXMLNodeI* p_psNode) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start CopyXMLRootNodeStructure")); +#endif + CreateXMLRootNode(p_psNode->GetName()); + + std::vector v_vRootAttributes = p_psNode->GetAttributes(); + mmInt v_iAttrCount = v_vRootAttributes.size(); + for(mmInt v_iA=0;v_iA v_vChilds = p_psNode->GetChilds(); + mmInt v_iChildsCount = v_vChilds.size(); + for(mmInt v_iC=0;v_iC v_sAttribs = p_psMMNode->GetAttributes(); + v_iCount = v_sAttribs.size(); + + + for(v_i=0;v_iget_attributes( &pXMLNamedNodeMap ); + + MSXML2::IXMLDOMNodePtr pAtty = + m_psXMLBBDoc->createNode( _variant_t( (long)MSXML2::NODE_ATTRIBUTE), _bstr_t(v_sAttribs[ v_i ].sName.c_str()), ""); + + pAtty->put_text( _bstr_t(v_sAttribs[ v_i ].sValue.c_str()) ); + pXMLNamedNodeMap->setNamedItem( pAtty); + + }; + + + // adding child nodes or text values for leaves + std::vector v_sChilds = p_psMMNode->GetChilds(); + v_iCount = v_sChilds.size(); + if(v_iCount > 0) + { + // childs + for(v_i=0;v_icreateNode(MSXML2::NODE_ELEMENT, _bstr_t(v_sChilds[v_i]->GetName().c_str()), ""); + + + v_sNewNode = p_sBBNode->appendChild(v_sNewNode); + FillXMLNodeIntoXMLDocument(v_sNewNode,v_sChilds[v_i]); + }; + } + else + { + // text + p_sBBNode->put_text(_bstr_t(p_psMMNode->GetText().c_str())); + }; +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End FillXMLNodeIntoXMLDocument")); +#endif +} + + +void mmXML::mmXMLDocBB::SaveNodeStructureIntoXMLDocument(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start SaveNodeStructureIntoXMLDocument")); +#endif + // delete existing XMLDocument + m_psXMLBBDoc.Release(); + + // create new one + InitializeXML(); + + wchar_t v_pcXML[1024]; + + swprintf_s(v_pcXML, 1023, L"%s <%s>", L"", m_sRootNode.GetName().c_str(), m_sRootNode.GetName().c_str()); + + m_psXMLBBDoc->loadXML(_bstr_t( v_pcXML )); + m_psDocRoot = m_psXMLBBDoc->documentElement; + + + FillXMLNodeIntoXMLDocument(m_psDocRoot,&m_sRootNode); + m_psXMLBBDoc->documentElement = m_psDocRoot; + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End SaveNodeStructureIntoXMLDocument")); +#endif +} + +mmString mmXML::mmXMLDocBB::GetXMLFormattedString(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start GetXMLFormattedString")); +#endif + mmString v_sOutString(L""); + + // formatowanie + + if( m_psXMLBBDoc == NULL ) + { + return v_sOutString; + } + + HRESULT hr = S_OK; + + MSXML2::IMXWriterPtr pMXWriter = NULL; + MSXML2::ISAXXMLReaderPtr pSAXReader = NULL; + MSXML2::ISAXContentHandlerPtr pISAXContentHandler = NULL; + MSXML2::ISAXErrorHandlerPtr pISAXErrorHandler = NULL; + MSXML2::ISAXDTDHandlerPtr pISAXDTDHandler = NULL; + try + { + + // create + hr = pMXWriter.CreateInstance( __uuidof(MSXML2::MXXMLWriter)); + if( FAILED(hr) ) + { + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + } + + hr = pSAXReader.CreateInstance( __uuidof(MSXML2::SAXXMLReader)); + if( FAILED(hr) ) + { + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + } + + // save in formatted + pISAXContentHandler = pMXWriter; + pISAXErrorHandler = pMXWriter; + pISAXDTDHandler = pMXWriter; + + if (FAILED (pMXWriter->put_omitXMLDeclaration (VARIANT_FALSE)) || + FAILED (pMXWriter->put_standalone (VARIANT_FALSE)) || + FAILED (pMXWriter->put_indent (VARIANT_TRUE)) || + FAILED (pMXWriter->put_encoding(_bstr_t("UTF-8")) ) + ) + { + + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + } + + if (FAILED(pSAXReader->putContentHandler (pISAXContentHandler)) || + FAILED(pSAXReader->putDTDHandler (pISAXDTDHandler)) || + FAILED(pSAXReader->putErrorHandler (pISAXErrorHandler)) || + FAILED(pSAXReader->putProperty ((unsigned short*)L"http://xml.org/sax/properties/lexical-handler", _variant_t(pMXWriter.GetInterfacePtr()))) || + FAILED(pSAXReader->putProperty ((unsigned short*)L"http://xml.org/sax/properties/declaration-handler", _variant_t(pMXWriter.GetInterfacePtr())))) + { + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + } + + IStream * pOutStream = NULL; + ::CreateStreamOnHGlobal( NULL, TRUE, &pOutStream); + + _bstr_t m_sString; + _variant_t out; + HGLOBAL hg = NULL; + hr = pMXWriter->put_output(_variant_t(pOutStream)); + GetHGlobalFromStream(pOutStream,&hg); + void * output; + output = GlobalLock(hg); + + + + if( FAILED(hr) ) + { + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + } + + hr = pSAXReader->parse(m_psXMLBBDoc.GetInterfacePtr()); + if( FAILED(hr) ) + { + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + } + + // zapisz do stringa + HRESULT hr = S_OK; + LPVOID pOutput = NULL; + HGLOBAL hGlobal = NULL; + + hr = ::GetHGlobalFromStream( pOutStream, &hGlobal); + if( FAILED(hr) ) + { + return v_sOutString; + } + ::GlobalUnlock(hGlobal); + LARGE_INTEGER llStart = {0, 0}; + ULARGE_INTEGER ullSize = {0, 0}; + pOutStream->Seek( llStart, STREAM_SEEK_CUR, &ullSize); + pOutput = ::GlobalLock(hGlobal); + + + char * v_pcText = new char[ int(ullSize.QuadPart) + 1 ]; + ZeroMemory( v_pcText, int(ullSize.QuadPart) + 1 ); + memcpy( v_pcText, (const char * ) pOutput, int(ullSize.QuadPart) ); + + v_sOutString.clear(); + v_sOutString.append( (mmStringUtilities::MMCharStringToMMString(v_pcText)).c_str()); + + + + ::GlobalUnlock(hGlobal); + delete [] v_pcText; + + } + catch ( _com_error e ) + { +// TRACE( _T("CXml::SaveWithFormatted( %s ) failed:%s\n"), lpszFilePath, e.ErrorMessage()); + hr = e.Error(); + } + RELEASE_PTR(pISAXDTDHandler); + RELEASE_PTR(pISAXErrorHandler); + RELEASE_PTR(pISAXContentHandler); + RELEASE_PTR(pSAXReader); + RELEASE_PTR(pMXWriter); + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End GetXMLFormattedString")); +#endif + + return v_sOutString; +} + +void mmXML::mmXMLDocBB::FillXMLNodeFromXMLDocument(MSXML2::IXMLDOMNodePtr p_sBBNode, mmXMLNodeI* p_psMMNode) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start FillXMLNodeFromXMLDocument")); +#endif + // adding attributes + mmInt v_i,v_iCount; + sXMLAttribute v_sXMLAttr; + + v_iCount = p_sBBNode->Getattributes()->Getlength(); + for(v_i=0;v_iGetattributes()->Getitem( v_i )->GetnodeName()); + v_sXMLAttr.sValue = (mmString)(const wchar_t *) _bstr_t (p_sBBNode->Getattributes()->Getitem( v_i )->GetnodeValue()); + + p_psMMNode->AddAttribute(v_sXMLAttr.sName,v_sXMLAttr.sValue); + }; + + // adding child nodes or text values for leafs + v_iCount = p_sBBNode->GetchildNodes()->Getlength(); + + if(v_iCount > 0) + { + // bylo 0! + + if( (v_iCount == 1) && ( Is_MSXML_Node(p_sBBNode->GetfirstChild()) == MSXML2::NODE_TEXT) ) + { + // text + p_psMMNode->SetText((mmString)(const wchar_t *)(p_sBBNode->Gettext())); + } + else + { + // childs + for(v_i=0;v_iAddChild((mmString)(const wchar_t *)(p_sBBNode->GetchildNodes()->Getitem(v_i)->GetnodeName())); + + FillXMLNodeFromXMLDocument(p_sBBNode->GetchildNodes()->Getitem(v_i),v_psChildNode); + }; + }; + }; +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End FillXMLNodeFromXMLDocument")); +#endif +} + +void mmXML::mmXMLDocBB::LoadNodeStructureFromXMLDocument(void) +{ +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"Start LoadNodeStructureFromXMLDocument")); +#endif + MSXML2::IXMLDOMElementPtr v_sRootNode = m_psXMLBBDoc->documentElement; + m_sRootNode.SetName((mmStringUtilities::MMCharStringToMMString((const char *) v_sRootNode->GetnodeName()))); +// m_sRootNode.SetName((mmString((const wchar_t *) v_sRootNode->GetnodeName()))); + FillXMLNodeFromXMLDocument(v_sRootNode,&m_sRootNode); + +#ifdef MADMAC + SendLogMessage(mmLog::debug,mmString(L"End LoadNodeStructureFromXMLDocument")); +#endif +} + + +bool mmXML::mmXMLDocBB::InitializeXML() +{ + m_sLastError = L"ok"; + + // -- Init OLE Object Comunication for MSXML (only once time)-- + // + + if(!m_bOLEInitialized) + { CoInitializeEx(NULL, COINIT_APARTMENTTHREADED ); + m_bOLEInitialized = true; + } + + // -- Instantiate an XML document -- + // + HRESULT hr = m_psXMLBBDoc.CreateInstance(MSXML2::CLSID_DOMDocument); + if (FAILED(hr)) + { + // coinit not called + if (hr == -2147221008) + { + m_bOLEInitialized = false; + InitializeXML(); + } + else + return false; + } + + return true; +} +void mmXML::mmXMLDocBB::Reset_XML_Document() +{ + // Init + // + this->InitializeXML(); + m_psDocRoot = m_psXMLBBDoc->documentElement; + + +} +bool mmXML::mmXMLDocBB::Load_XML_Document(mmString strFileName) +{ + m_sLastError = L"ok"; + + // Reset Document + // + this->Reset_XML_Document(); + + // Convert xml file name string to something COM can handle (BSTR) + // + //mmString sFileName = strFileName; + //_bstr_t bstrFileName; + //bstrFileName = sFileName.AllocSysString(); + + // Call the MSXML2::IXMLDOMDocumentPtr's load function to load the XML document + // + variant_t vResult; + // UWAGA - VS 2008 SP1 - load nie dziala, trzeba loadXML + vResult = m_psXMLBBDoc->load (_bstr_t(strFileName.c_str())); + if (((bool)vResult) == TRUE) // success! + { + // Now that the document is loaded, we need to initialize the root pointer + // + m_psDocRoot = m_psXMLBBDoc->documentElement; + + + + return true; + } + else + { // XML document is not loaded, return error + // + m_sLastError = L"XML Document FAILED to load"; + return false; + } +} + +void mmXML::mmXMLDocBB::Load_XML_From_Buffer(mmString source) +{ + // Reset the document + // + this->Reset_XML_Document(); + + // Load from Buffer + // + variant_t vResult; + // UWAGA - VS 2008 SP1 - load nie dziala, trzeba loadXML + vResult = m_psXMLBBDoc->loadXML(_bstr_t(source.c_str())); + if (((bool)vResult) == TRUE) // success! + { + // Now that the document is loaded, we need to initialize the root pointer + // + m_psDocRoot = m_psXMLBBDoc->documentElement; + + + + return ; + } + else + { // XML document is not loaded, return error + // + MSXML2::IXMLDOMParseErrorPtr v_ptr = m_psXMLBBDoc->parseError; + m_sLastError = v_ptr->reason; + return ; + } + + +} + +