parallel_worlds_1/build/cmakefiles/3.1.0-rc1/compileridcxx/debug/CompilerIdCXX.tlog/CompilerIdCXX.lastbuildstate

-#TargetFrameworkVersion=v4.0:PlatformToolSet=v120:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit
-Debug|x64|C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\build\CMakeFiles\3.1.0-rc1\CompilerIdCXX\|

parallel_worlds_1/build/cmakefiles/c312c3e5c19bfdb1dce1b8a756fc3edc/generate.stamp.rule

-# generated from CMake

parallel_worlds_1/build/debug/src/CMakeLists.txt

-cmake_minimum_required( VERSION 3.1 )
-project( parallelwelten_1 )
-
-set( EXECUTABLE parallelwelten_1 )
-
-if( MSVC )
-	message( "MSVC: adding compiler flags" )
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE2 /I.")
-endif( MSVC )
-
-if( UNIX )
-	message( "UNIX-like system: adding compiler flags" )
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2 -I.")
-endif( UNIX )
-
-find_package( OpenCV REQUIRED )
-include_directories( ${OpenCV_INCLUDE_DIRS} )
-
-find_package( OpenCL REQUIRED )
-
-include_directories( ${OpenCL_INCLUDE_DIRS} )
-set(OpenCL_INCLUDE_DIRS ${OpenCL_INCLUDE_DIRS} CACHE FILEPATH "OpenCL include directory")
-set(OpenCL_LIBRARIES ${OpenCL_LIBRARIES} CACHE FILEPATH "OpenCL libraries")
-
-message( "OpenCL include directory is: " ${OpenCL_INCLUDE_DIRS} )
-
-add_executable( ${EXECUTABLE} main.cpp )
-target_link_libraries( ${EXECUTABLE} ${OpenCL_LIBRARIES} )
-target_link_libraries( ${EXECUTABLE} ${OpenCV_LIBS} )
-
-# copy src for .cl files so that they can probably be read if someone
-# just starts the program
-add_custom_command(TARGET ${EXECUTABLE} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory "${PROJECT_SOURCE_DIR}" "$<TARGET_FILE_DIR:${EXECUTABLE}>/src")
-add_custom_command(TARGET ${EXECUTABLE} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy "${PROJECT_SOURCE_DIR}/../preview.png" "$<TARGET_FILE_DIR:${EXECUTABLE}>")
-

parallel_worlds_1/build/debug/src/DeviceInterface.hpp

-#ifndef _DEVICE_INTERFACE_HPP_
-#define _DEVICE_INTERFACE_HPP_
-
-#include <assert.h>
-
-/// representation of platform / device /queue;
-/// looks for the first GPU device it can find
-// (and settles for a CPU device if none is found) for OpenCL
-// computations
-class DeviceInterface {
-private:
-
-	// vector of all appropriate devices
-	VECTOR_CLASS<cl::Device> devices;
-
-	/// a context stores information on device properties that are
-	// needed to compile programs for that device (or a group of devices);
-	// it is therefore needed to compile an OpenCL program
-	cl::Context context;
-
-	/// a queue may be used to submit kernels (functions of
-	// compiled OpenCL programs) to a specific device; it is therefore
-	// dependent on a certain context and may be used to enqueue a kernel
-	// call to one of the (potentially several) devices referenced
-	// in the context
-	cl::CommandQueue queue;
-
-	/// returns the first devices found of type devType in device;
-	// @param devType type of the device to be returned
-	// @param deviceVector vector storing the devices
-	// @param reference to the device to be returned
-	// @returns true, iff a device of the appropriate type
-	// could be found
-	static bool getFirstDevices(cl_device_type devType,
-			VECTOR_CLASS<cl::Device> &deviceVector) {
-		VECTOR_CLASS<cl::Platform> platforms;
-		// query all platforms
-		SAFE_CALL(cl::Platform::get(&platforms));
-		/* the C-way:
-		 * cl_int clGetPlatformIDs (cl_uint num_entries,
-		 * cl_platform_id *platforms,
-		 * cl_uint *num_platforms)
-		 */
-		for (VECTOR_CLASS<cl::Platform>::iterator pit = platforms.begin();
-				platforms.end() != pit; ++pit) {
-			// try to find a device of type devType
-			CHECK_ERROR(pit->getDevices(devType, &deviceVector));
-			/* the C-way:
-			 * cl_int clGetDeviceIDs (cl_platform_id platform,
-			 * cl_device_type device_type,
-			 * cl_uint num_entries,
-			 * cl_device_id *devices,
-			 * cl_uint *num_devices)
-			 */
-			if (deviceVector.size() > 0) {
-				return true;
-			}
-		}
-		// no appropriate device found => return false
-		return false;
-	}
-
-	/// find a GPU device -- if none is found, use a CPU device
-	// @returns a vector of all appropriate devices of the same
-	// platform (usually, there will be only 1 matching device)
-	static VECTOR_CLASS<cl::Device> findDevices() {
-		VECTOR_CLASS<cl::Device> devices;
-		// try to get GPU device (otherwise use CPU)
-		std::cerr << "Found: ";
-		if (getFirstDevices(CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR,
-				devices)) {
-			std::cerr << "GPU/ACCELERATOR device." << std::endl;
-		} else {
-			if (getFirstDevices(CL_DEVICE_TYPE_CPU, devices)) {
-				std::cerr << "CPU device." << std::endl;
-			} else {
-				std::cerr << "NO device." << std::endl;
-			}
-		}
-		return devices;
-	}
-
-	void init() {
-		devices = findDevices();
-		// In order to execute a kernel (OpenCL program), it is necessary to first define
-		// some hardware presentations:
-		// 1. a context that defines the devices (and thus the usable binary code)
-		//    that can be used
-		// 2. a command queue that manages kernel execution (when to run which kernel)
-
-		// create a context containing only the devices of this platform
-		context = cl::Context(devices);
-		/* The C-way:
-		 * cl_context clCreateContext (const cl_context_properties *properties,
-		 * cl_uint num_devices,
-		 * const cl_device_id *devices,
-		 * void (CL_CALLBACK *pfn_notify)(const char *errinfo,
-		 * const void *private_info, size_t cb,
-		 * void *user_data),
-		 * void *user_data,
-		 * cl_int *errcode_ret)
-		 */
-
-		// create a command queue for the context -- use the first device found
-		queue = cl::CommandQueue(context, this->getDevice(), 0 /* queue properties */,
-				&errorCode);
-		CHECK_ERROR(errorCode);
-		/* The C-way:
-		 * cl_command_queue clCreateCommandQueue (cl_context context,
-		 * cl_device_id device,
-		 * cl_command_queue_properties properties,
-		 * cl_int *errcode_ret)
-		 */
-	}
-
-public:
-	DeviceInterface() {
-		init();
-	}
-	DeviceInterface(VECTOR_CLASS<cl::Device> devs,cl::Context ctx,cl::CommandQueue q):devices(devs),
-			context(ctx),queue(q){};
-	virtual ~DeviceInterface() {
-	}
-
-	const cl::Context &getContext() const {
-		return context;
-	}
-
-	const cl::CommandQueue &getQueue() const {
-		return queue;
-	}
-
-	/// if a specific device has to be used, always
-	// just use the first one here -- of course,
-	// one could do better...
-	const cl::Device &getDevice(unsigned int i=0) const {
-		assert(devices.size()>i);
-		return devices[i];
-	}
-};
-
-#endif

parallel_worlds_1/build/debug/src/ImageFilter.hpp

-#ifndef _IMAGE_FILTER_HPP_
-#define _IMAGE_FILTER_HPP_
-
-#include "ProgramInterface.hpp"
-
-/// A kernel that has one image as
-// input and one as output; the kernel for this image filter
-// has to take exactly 4 arguments:
-// 1. pointer to the input image data
-// 2. pointer to the output image data
-// 3. image width
-// 4. image height
-// the kernel is then called once for each pixel of the image
-// (and needs to know the data format by itself)
-class ImageFilter: public ProgramInterface {
-protected:
-	/// pointer to the input image data
-	cl::Buffer inputBuffer;
-	/// pointer to the output image data
-	cl::Buffer outputBuffer;
-	/// image width
-	unsigned int width;
-	/// image height
-	unsigned int height;
-	/// color depth in bytes (input)
-	unsigned int depthIn;
-	/// color depth in bytes (output)
-	unsigned int depthOut;
-public:
-	ImageFilter(const DeviceInterface&dev, std::string programText,
-			std::string kernelName,unsigned int dIn,unsigned int dOut, bool buildKernelFromFile=true) :
-			ProgramInterface(dev, programText, kernelName,buildKernelFromFile), width(0), height(0),
-			depthIn(dIn),depthOut(dOut){
-	}
-	;
-	virtual ~ImageFilter() {
-	}
-	;
-	/// resizes inputBuffer/outputBuffer so that each can take a color image
-	// of the specified width & height
-	void resizeBuffers(unsigned int currWidth,unsigned int currHeight) {
-		unsigned int bytesIn = currWidth * currHeight * depthIn;
-		unsigned int bytesOut = currWidth * currHeight * depthOut;
-		// if the image is larger than input/output buffers,
-		// create new buffers
-		if (currWidth * currHeight > width * height) {
-			inputBuffer = cl::Buffer(deviceInterface.getContext(),
-					CL_MEM_READ_ONLY, bytesIn, NULL,
-					&errorCode);
-			CHECK_ERROR(errorCode);
-			/* The C-way:
-			 * cl_mem clCreateBuffer (cl_context context,
-			 * cl_mem_flags flags,
-			 * size_t size,
-			 * void *host_ptr,
-			 * cl_int *errcode_ret)
-			 */
-			outputBuffer = cl::Buffer(deviceInterface.getContext(),
-					CL_MEM_WRITE_ONLY, bytesOut, NULL,
-					&errorCode);
-			CHECK_ERROR(errorCode);
-
-			width = currWidth;
-			height = currHeight;
-		}
-
-	}
-	void operator()(unsigned char*input, unsigned char*output, unsigned int currWidth,
-			unsigned int currHeight) {
-		unsigned int bytesIn = currWidth * currHeight * depthIn;
-		unsigned int bytesOut = currWidth * currHeight * depthOut;
-		resizeBuffers(currWidth,currHeight);
-		// the frame is to be passed as an argument to the kernel function
-		// the actual call to the kernel function is represented by an
-		// object of type cl::Kernel which stores the kernel arguments
-		setArg(0, inputBuffer);
-		setArg(1, outputBuffer);
-
-		// image width/height has to be passed anyway for each new input image
-		setArg(2, currWidth);
-		setArg(3, currHeight);
-
-		// copy frame from CPU to GPU memory
-		SAFE_CALL(
-				deviceInterface.getQueue().enqueueWriteBuffer(inputBuffer,
-						CL_TRUE, 0, bytesIn, input));
-		/* The C-way:
-		 * cl_int clEnqueueWriteBuffer (cl_command_queue command_queue,
-		 *     cl_mem buffer,cl_bool blocking_write,size_t offset,size_t size,
-		 *     const void *ptr,cl_uint num_events_in_wait_list,
-		 *     const cl_event *event_wait_list,cl_event *event)
-		 */
-
-		// call the kernel
-		SAFE_CALL(
-				deviceInterface.getQueue().enqueueNDRangeKernel(kernel,
-						cl::NullRange /* offset */,
-						cl::NDRange(width,
-								height) /* global size (number of work items) */,
-						cl::NullRange /* work group size (here selected by OpenCL) */));
-		/*
-		 * The C-way:
-		 * cl_int clEnqueueNDRangeKernel (cl_command_queue command_queue,cl_kernel kernel,
-		 *     cl_uint work_dim,const size_t *global_work_offset,const size_t *global_work_size,
-		 *     const size_t *local_work_size,cl_uint num_events_in_wait_list,
-		 *     const cl_event *event_wait_list,cl_event *event)
-		 *
-		 */
-
-		// finish all enqueued commands -- i.e., wait for kernel to finish
-		SAFE_CALL(deviceInterface.getQueue().finish());
-		/* The C-way:
-		 * cl_int clFinish (cl_command_queue command_queue)
-		 */
-		// copy frame from GPU to CPU memory
-		SAFE_CALL(
-				deviceInterface.getQueue().enqueueReadBuffer(outputBuffer,
-						CL_TRUE, 0, bytesOut, output));
-		/*
-		 * The C-way:
-		 * cl_int clEnqueueReadBuffer (cl_command_queue command_queue,cl_mem buffer,
-		 *     cl_bool blocking_read,size_t offset,size_t size,void *ptr,
-		 *     cl_uint num_events_in_wait_list,const cl_event *event_wait_list,
-		 *     cl_event *event)
-		 */
-	}
-};
-
-DeviceInterface defaultDevice;
-ImageFilter greyFilter(defaultDevice, "src/greyImageFilters.cl", "grey", 3, 1,true);
-
-#endif

parallel_worlds_1/build/debug/src/OpenCLInterface.hpp

-#ifndef OPENCL_INTERFACE_HPP_
-#define OPENCL_INTERFACE_HPP_
-
-#include <iostream>
-#include <sstream>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "cl.hpp"
-
-/*
- * VECTOR_CLASS and STRING_CLASS are defined by OpenCL so that
- * the user may use her own implementation of these classes, if she
- * wants to avoid the STL; the defines below are only safeguards to have
- * all these definitions available
- */
-#ifndef STRING_CLASS
-#define STRING_CLASS cl::STRING_CLASS
-#endif
-#ifndef VECTOR_CLASS
-#define VECTOR_CLASS cl::VECTOR_CLASS
-#endif
-
-/*
- * Defines for use in OpenCL functions that return an error code;
- * these defines query the return code and produce an exception, if
- * an error occurs
- */
-#define STRG(y) (#y)
-// STRING can be used to create an error message and to produce
-// a program text for OpenCL kernels
-#define STRING(x) (STRING_CLASS(STRG(x)))
-
-#define CL_ERROR(fct,line,errorCode) do{std::stringstream ss;ss << STRING_CLASS("FAILED CALL (at '")+ __FILE__ +"', line "+STRING(__LINE__)+"): "+(#fct)+" failed with "<<errorCode<<"."; std::cerr<<ss.str()<<std::endl;exit(1);}while(0)
-#define SAFE_CALL(fct_call) do{cl_int errC = fct_call; if(CL_SUCCESS!=(errC)){CL_ERROR(fct_call,__LINE__,errC);}}while(0)
-#define CHECK_ERROR(errCode) do{SAFE_CALL(errCode);}while(0)
-
-// ATTENTION: this declaration makes the error checking code unsafe in threaded environments!
-static cl_int errorCode;
-
-#include "DeviceInterface.hpp"
-#include "ProgramInterface.hpp"
-
-#endif

parallel_worlds_1/build/debug/src/ProgramInterface.hpp

-#ifndef _PROGRAM_INTERFACE_HPP_
-#define _PROGRAM_INTERFACE_HPP_
-
-#include <string>
-#include <fstream>
-
-#include "DeviceInterface.hpp"
-
-class ProgramInterface {
-protected:
-	/// description of the platform/device/queue to be used
-	DeviceInterface deviceInterface;
-
-	/// each kernel invocation is represented by an object of type kernel
-	cl::Kernel kernel;
-
-public:
-	/// contructor needs description of the hardware
-	// in order to be able to compile programs for it
-	ProgramInterface(const DeviceInterface&dev, std::string programText,
-			std::string kernelName, bool buildKernelFromFile=true) :
-			deviceInterface(dev) {
-		if(buildKernelFromFile){
-			kernelFromFile(programText, kernelName);
-		} else {
-			kernelFromString(programText, kernelName);
-		}
-	}
-	virtual ~ProgramInterface() {
-	}
-
-	cl::Program buildProgram(std::string programText) {
-		// create a program object and immediately compile the program text for it (build=true)
-		// into a binary form that can be executed on the devices of the given context;
-		cl::Program program(deviceInterface.getContext(), programText, true,
-				&errorCode);
-		/* The C-way:
-		 * creating a program object:
-		 * cl_program clCreateProgramWithSource (cl_context context,
-		 * cl_uint count,
-		 * const char **strings,
-		 * const size_t *lengths,
-		 * cl_int *errcode_ret)
-		 * building a program (compile & link -- can also be done separately):
-		 * cl_int clBuildProgram (cl_program program,
-		 * cl_uint num_devices,
-		 * const cl_device_id *device_list,
-		 * const char *options,
-		 * void (CL_CALLBACK *pfn_notify)(cl_program program,
-		 * void *user_data),
-		 * void *user_data)
-		 */
-
-		// if the compilation failed, get a more precise error message
-		if (CL_BUILD_PROGRAM_FAILURE == errorCode) {
-			std::string buildInfo = "";
-			buildInfo = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(
-					deviceInterface.getDevice());
-			/*
-			 * The C-way:
-			 * cl_int clGetProgramBuildInfo (cl_program program,cl_device_id device,
-			 *     cl_program_build_info param_name,size_t param_value_size,
-			 *     void *param_value,size_t *param_value_size_ret)
-			 */
-			std::cerr<<"OpenCL build error:\n"<<buildInfo<<std::endl;
-		}
-		CHECK_ERROR(errorCode);
-		return program;
-	}
-
-	/// creating an actual kernel program consists of
-	// 1. creating a program object
-	// 2. building a program by
-	//    a. compiling some program text for use on the device(s)
-	//    b. linking the program (e.g. with library functions)
-	// in C++, these steps can all be performed simply by calling the
-	// Program constructor
-	void kernelFromString(std::string programText, std::string kernelName) {
-		cl::Program program = buildProgram(programText);
-		// the frame is to be passed as an argument to the kernel function
-		// the actual call to the kernel function is represented by an
-		// object of type cl::Kernel which stores the kernel arguments
-		kernel = cl::Kernel(program, kernelName.c_str(), &errorCode);
-		CHECK_ERROR(errorCode);
-		/* The C-way:
-		 * cl_kernel clCreateKernel (cl_program program,
-		 * const char *kernel_name,
-		 * cl_int *errcode_ret)
-		 */
-	}
-
-	/// construct a kernel reading the program text from a file
-	// (has to be placed in the cwd -- for eclipse usually the project directory)
-	void kernelFromFile(std::string programTextFileName,std::string kernelName){
-		std::ifstream inputStream(programTextFileName.c_str());
-		if(!inputStream){
-			std::cerr<<"could not open file "<<programTextFileName<<" -- wrong CWD?"<<std::endl;
-			exit(1);
-		}
-		std::string programText = "";
-		std::string programLine;
-		while(std::getline(inputStream,programLine)){
-			programText += programLine + "\n";
-		}
-		kernelFromString(programText,kernelName);
-	}
-
-
-	cl::Kernel &getKernel() {
-		return kernel;
-	}
-
-	template<typename T> void setArg(unsigned int num, T&argument) {
-		SAFE_CALL(kernel.setArg(num, argument));
-		/* The C-way:
-		 * cl_int clSetKernelArg (cl_kernel kernel,
-		 * cl_uint arg_index,
-		 * size_t arg_size,
-		 * const void *arg_value)
-		 */
-	}
-
-	void setArg(unsigned int num, size_t arraySize, void *arrayPtr) {
-		SAFE_CALL(kernel.setArg(num, arraySize, arrayPtr));
-		/* The C-way:
-		 * cl_int clSetKernelArg (cl_kernel kernel,
-		 * cl_uint arg_index,
-		 * size_t arg_size,
-		 * const void *arg_value)
-		 */
-	}
-
-};
-
-#endif /* PROGRAMINTERFACE_HPP_ */

parallel_worlds_1/build/debug/src/greyImageFilters.cl

-        /* start the kernel with one work-item per pixel
-        ** first work-dimension (0) is image width (x)
-        */
-        __kernel void grey(__global unsigned char *inImg,
-                            __global unsigned char *outImg,
-                            __private unsigned int w,__private unsigned int h) {
-            __private unsigned int x;__private unsigned int y;
-            x = get_global_id(0);
-            y = get_global_id(1);
-            if(y<h) {
-                if(x<w) {
-                    // greyscale conversion (c.f. http://en.wikipedia.org/wiki/Grayscale)
-                    // Y = 0.2126R + 0.7152G + 0.0722B
-                    outImg[x+w*y] = 0.0722 * inImg[3*(x+w*y)] /* blue */
-                    + 0.7152 * inImg[3*(x+w*y)+1]             /* green */
-                    + 0.2126 * inImg[3*(x+w*y)+2];            /* red */
-                }
-            }
-        }

parallel_worlds_1/build/debug/src/main.cpp

-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-
-#include "OpenCLInterface.hpp"
-#include "ImageFilter.hpp"
-
-int main(int argc, const char** argv) {
-	cv::VideoCapture capture(0); //0=default, -1=any camera, 1..99=your camera
-	cv::Mat frame;
-
-	bool cameraOn = capture.isOpened();
-	if (cameraOn) {
-		if (!capture.read(frame))
-			exit(3);
-	} else {
-		std::cerr << "No camera detected" << std::endl;
-		frame = cv::imread("preview.png");
-		if(frame.data == NULL)
-			exit(3);
-	}
-
-	const unsigned int w = frame.cols;
-	const unsigned int h = frame.rows;
-
-	// resulting image after conversion is greyscale
-	cv::Mat convertedFrame(h, w, CV_8UC1);
-	cv::namedWindow("preview", 0);
-	cv::namedWindow("converted", 0);
-
-	while (cv::waitKey(10) < 0) {
-		if (cameraOn && !capture.read(frame))
-			exit(3);
-
-		greyFilter(frame.data, convertedFrame.data, w, h);
-		// show the result
-		cv::imshow("preview", frame);
-		cv::imshow("converted", convertedFrame);
-	}
-
-	cv::destroyWindow("preview");
-	cv::destroyWindow("converted");
-
-	return 0;
-}

parallel_worlds_1/build/parallelwelten_1.dir/Debug/parallelwelten_1.log

-Der Buildvorgang wurde am 08.11.2014 17:56:44 gestartet.
-     1>Projekt "C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\build\parallelwelten_1.vcxproj" auf Knoten "2", Build Ziel(e).
-     1>CustomBuild:
-         Building Custom Rule C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/src/CMakeLists.txt
-         CMake does not need to re-run because C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\build\CMakeFiles\generate.stamp is up-to-date.
-       ClCompile:
-         C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\CL.exe /c /I. /IC:\Users\Tanja\Desktop\opencv\opencv\build\include /IC:\Users\Tanja\Desktop\opencv\opencv\build\include\opencv /I"C:\Program Files (x86)\AMD APP SDK\2.9\include" /Zi /nologo /W3 /WX- /Od /Ob0 /D WIN32 /D _WINDOWS /D _DEBUG /D "CMAKE_INTDIR=\"Debug\"" /D _MBCS /Gm- /EHsc /RTC1 /MDd /GS /arch:SSE2 /fp:precise /Zc:wchar_t /Zc:forScope /GR /Fo"parallelwelten_1.dir\Debug\\" /Fd"parallelwelten_1.dir\Debug\vc120.pdb" /Gd /TP /errorReport:prompt C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\src\main.cpp
-     1>cl : Befehlszeile warning D9002: Unbekannte Option "/arch:SSE2" wird ignoriert.
-         main.cpp
-       Link:
-         C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\link.exe /ERRORREPORT:PROMPT /OUT:"C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\build\Debug\parallelwelten_1.exe" /INCREMENTAL /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib "C:\Program Files (x86)\AMD APP SDK\2.9\lib\x86_64\OpenCL.lib" C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_videostab248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_video248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_ts248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_superres248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_stitching248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_photo248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_ocl248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_objdetect248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_nonfree248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_ml248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_legacy248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_imgproc248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_highgui248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_gpu248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_flann248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_features2d248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_core248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_contrib248d.lib C:\Users\Tanja\Desktop\opencv\opencv\build\x64\vc12\lib\opencv_calib3d248d.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/build/Debug/parallelwelten_1.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/build/Debug/parallelwelten_1.lib" /MACHINE:X64  /machine:x64 /debug parallelwelten_1.dir\Debug\main.obj
-         parallelwelten_1.vcxproj -> C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\build\Debug\parallelwelten_1.exe
-       PostBuildEvent:
-         setlocal
-         "C:\Program Files (x86)\CMake\bin\cmake.exe" -E copy_directory C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/src C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/build/Debug/src
-         if %errorlevel% neq 0 goto :cmEnd
-         :cmEnd
-         endlocal & call :cmErrorLevel %errorlevel% & goto :cmDone
-         :cmErrorLevel
-         exit /b %1
-         :cmDone
-         if %errorlevel% neq 0 goto :VCEnd
-         setlocal
-         "C:\Program Files (x86)\CMake\bin\cmake.exe" -E copy C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/src/../preview.png C:/Users/Tanja/Desktop/ct_projekt/8/parallelwelten_1/build/Debug
-         if %errorlevel% neq 0 goto :cmEnd
-         :cmEnd
-         endlocal & call :cmErrorLevel %errorlevel% & goto :cmDone
-         :cmErrorLevel
-         exit /b %1
-         :cmDone
-         if %errorlevel% neq 0 goto :VCEnd
-         :VCEnd
-     1>Die Erstellung des Projekts "C:\Users\Tanja\Desktop\ct_projekt\8\parallelwelten_1\build\parallelwelten_1.vcxproj" ist abgeschlossen, Build Ziel(e).
-
-Build erfolgreich.
-
-Verstrichene Zeit 00:00:24.10