X86MAC64/mrcImageDataSet.o:mrcImageDataSet.o
X86MAC64/mrcImageError.o:mrcImageError.o
X86MAC64/mrcImageGet.o:mrcImageGet.o
+X86MAC64/mrcImageGetPixels.o:mrcImageGetPixels.o
X86MAC64/mrcImageInfo.o:mrcImageInfo.o
X86MAC64/mrcImageInit.o:mrcImageInit.o
X86MAC64/mrcImageOperation.o:mrcImageOperation.o
mrcImageDataSet.c \
mrcImageError.c \
mrcImageGet.c \
+mrcImageGetPixels.c \
mrcImageInfo.c \
mrcImageInit.c \
mrcImageOperation.c \
mrcRefUtil.c \
lmrcImageAddValueCuda.cu \
lmrcImageClusterAnalysis.cu \
+mrcImageGetPixelsCUDA.cu \
OBJ = \
fftn.o \
mrcImageDataSet.o \
mrcImageError.o \
mrcImageGet.o \
+mrcImageGetPixels.o \
mrcImageInfo.o \
mrcImageInit.o \
mrcImageOperation.o \
mrcRefUtil.o \
lmrcImageAddValueCuda.o \
lmrcImageClusterAnalysis.o \
+mrcImageGetPixelsCUDA.o \
SHAREDOBJ = \
fftn.sharedo \
mrcImageDataSet.sharedo \
mrcImageError.sharedo \
mrcImageGet.sharedo \
+mrcImageGetPixels.sharedo \
mrcImageInfo.sharedo \
mrcImageInit.sharedo \
mrcImageOperation.sharedo \
mrcRefUtil.sharedo \
lmrcImageAddValueCuda.sharedo \
lmrcImageClusterAnalysis.sharedo \
+mrcImageGetPixelsCUDA.sharedo \
REALOBJ = \
X86MAC64/fftn.o \
X86MAC64/mrcImageDataSet.o \
X86MAC64/mrcImageError.o \
X86MAC64/mrcImageGet.o \
+X86MAC64/mrcImageGetPixels.o \
X86MAC64/mrcImageInfo.o \
X86MAC64/mrcImageInit.o \
X86MAC64/mrcImageOperation.o \
X86MAC64/mrcRefUtil.o \
X86MAC64/lmrcImageAddValueCuda.o \
X86MAC64/lmrcImageClusterAnalysis.o \
+X86MAC64/mrcImageGetPixelsCUDA.o \
REALSHAREDOBJ = \
X86MAC64/fftn.sharedo \
X86MAC64/mrcImageDataSet.sharedo \
X86MAC64/mrcImageError.sharedo \
X86MAC64/mrcImageGet.sharedo \
+X86MAC64/mrcImageGetPixels.sharedo \
X86MAC64/mrcImageInfo.sharedo \
X86MAC64/mrcImageInit.sharedo \
X86MAC64/mrcImageOperation.sharedo \
X86MAC64/mrcRefUtil.sharedo \
X86MAC64/lmrcImageAddValueCuda.sharedo \
X86MAC64/lmrcImageClusterAnalysis.sharedo \
+X86MAC64/mrcImageGetPixelsCUDA.sharedo \
OBJDEBUG = \
fftn.debugo \
mrcImageDataSet.debugo \
mrcImageError.debugo \
mrcImageGet.debugo \
+mrcImageGetPixels.debugo \
mrcImageInfo.debugo \
mrcImageInit.debugo \
mrcImageOperation.debugo \
X86MAC64/mrcImageDataSet.debugo \
X86MAC64/mrcImageError.debugo \
X86MAC64/mrcImageGet.debugo \
+X86MAC64/mrcImageGetPixels.debugo \
X86MAC64/mrcImageInfo.debugo \
X86MAC64/mrcImageInit.debugo \
X86MAC64/mrcImageOperation.debugo \
X86MAC64/mrcRefUtil.debugo \
X86MAC64/lmrcImageAddValueCuda.debugo \
X86MAC64/lmrcImageClusterAnalysis.debugo \
+X86MAC64/mrcImageGetPixelsCUDA.debugo \
OBJCUDAGDB = \
fftn.cudagdb.o \
mrcImageDataSet.cudagdb.o \
mrcImageError.cudagdb.o \
mrcImageGet.cudagdb.o \
+mrcImageGetPixels.cudagdb.o \
mrcImageInfo.cudagdb.o \
mrcImageInit.cudagdb.o \
mrcImageOperation.cudagdb.o \
mrcRefUtil.cudagdb.o \
lmrcImageAddValueCuda.cudagdb.o \
lmrcImageClusterAnalysis.cudagdb.o \
+mrcImageGetPixelsCUDA.cudagdb.o \
REALOBJCUDAGDB = \
X86MAC64/fftn.cudagdb.o \
X86MAC64/mrcImageDataSet.cudagdb.o \
X86MAC64/mrcImageError.cudagdb.o \
X86MAC64/mrcImageGet.cudagdb.o \
+X86MAC64/mrcImageGetPixels.cudagdb.o \
X86MAC64/mrcImageInfo.cudagdb.o \
X86MAC64/mrcImageInit.cudagdb.o \
X86MAC64/mrcImageOperation.cudagdb.o \
X86MAC64/mrcRefUtil.cudagdb.o \
X86MAC64/lmrcImageAddValueCuda.cudagdb.o \
X86MAC64/lmrcImageClusterAnalysis.cudagdb.o \
+X86MAC64/mrcImageGetPixelsCUDA.cudagdb.o \
--- /dev/null
+../mrcImageGetPixels.c
\ No newline at end of file
--- /dev/null
+../mrcImageGetPixelsCUDA.cu
\ No newline at end of file
$(SHAREDLIB): $(SHAREDOBJ)
@COMPILEDOBJ=`ls $(SHAREDOBJ)` ; echo "#### Compiled Objects"; echo $${COMPILEDOBJ}; echo "################"; \
- $(SHARED) $(SHAREDLIB) $${COMPILEDOBJ}
+ COMMAND="$(SHARED) $(SHAREDLIB) $${COMPILEDOBJ}" ; echo $${COMMAND}; $${COMMAND}
debug: $(LIBNAMEDEBUG) $(LIBNAMECUDAGDB)
/usr/include/sys/_types/_dev_t.h /usr/include/sys/_types/_mode_t.h \
/Users/tacyas/Eos/include/string.h /usr/include/math.h ../inc/config.h \
../inc/../inc/mrcImagePixelDataGet.h \
- /Users/tacyas/Eos/include/genUtil.h \
- /Users/tacyas/Eos/include/mrcImage.h \
- /Users/tacyas/Eos/include/ctfInfo.h /Users/tacyas/Eos/include/Vector.h \
- /Users/tacyas/Eos/include/Matrix3D.h /Users/tacyas/Eos/include/Array.h
+ /Users/tacyas/Eos/include/genUtil.h /Users/tacyas/Eos/include/Memory.h \
+ /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/5.1/include/limits.h \
+ /usr/include/limits.h /usr/include/machine/limits.h \
+ /usr/include/i386/limits.h /usr/include/i386/_limits.h \
+ /usr/include/sys/syslimits.h /Users/tacyas/Eos/include/mrcImage.h \
+ /Users/tacyas/Eos/include/Matrix3D.h \
+ /Users/tacyas/Eos/include/Vector.h /Users/tacyas/Eos/include/Array.h \
+ /Users/tacyas/Eos/include/ctfInfo.h \
+ /Users/tacyas/Eos/include/eosPoint.h \
+ /Users/tacyas/Eos/include/eosCuda.h
usage.o: usage.c /usr/include/stdio.h /usr/include/sys/cdefs.h \
/usr/include/sys/_symbol_aliasing.h \
/usr/include/sys/_posix_availability.h /usr/include/Availability.h \
#include <stdio.h>
#include <math.h>
#include "genUtil.h"
+#include "Matrix3D.h"
/* struct begin */
mrcPixelDataType mode,
mrcPixelDataHowToGet how);
+extern void mrcPixelsDataGet(float* data, mrcImageParaTypeRealCoord* inCoord, int nPixel, mrcImage* in, mrcPixelDataType type, mrcPixelDataHowToGet howto);
+extern void mrcPixelDataGetbyMatrix3D(mrcImage* out, mrcImage* in, Matrix3D mat, mrcPixelDataHowToGet mode, int mode2);
+
static inline double mrcPixelDataGetFloatImage(mrcImage* img,
mrcImageParaTypeInteger x, mrcImageParaTypeInteger y, mrcImageParaTypeInteger z)
{
--- /dev/null
+/*
+# mrcImageGetPixelsCUDA.h : $Revision$
+# $Date$
+# Created by $Author$
+# Usage : mrcImageGetPixelsCUDA.h
+# Attention
+# $Loccker$
+# $State$
+#
+*/
+/* $Log$ */
+#ifndef MRCIMAGE_GET_PIXELS_CUDA_H
+#define MRCIMAGE_GET_PIXELS_CUDA_H
+
+#include <stdio.h>
+
+/* constant begin */
+
+
+/* constant end */
+
+/* struct begin */
+
+
+/* struct end */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* prototype begin */
+
+extern void mrcPixelsDataGetCUDA(float* out, float* inCoord, int num, float* in, mrcImageMode imageMode, int nx, int ny, int nz, mrcPixelDataType type, mrcPixelDataHowToGet howToMode);
+
+
+extern void mrcPixelDataGetbyMatrix3DCUDA(float* out, float* mat, float* in, mrcImageMode imageMode, int nx, int ny, int nz, mrcPixelDataType type, mrcPixelDataHowToGet howToMode);
+
+
+/* prototype end */
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* MRCIMAGE_GET_PIXELS_CUDA_H */
#NVCC = nvcc
NVCC = /Developer/NVIDIA/CUDA-5.5/bin/nvcc -ccbin /usr/bin/clang
-NVCCOPTS = $(CUDACCOPTS) --host-compilation='C++' -ccbin /usr/bin/clang \
+NVCCOPTS = $(CUDACCOPTS) --host-compilation='C++' \
-I../../common/inc -m64 \
-Xcompiler -arch -Xcompiler x86_64 -Xcompiler -stdlib=libstdc++ \
-gencode arch=compute_10,code=sm_10
-NVCCOPTSGDB = $(CUDACCOPTSDEBUG) -g -G --host-compilation='C++' -ccbin /usr/bin/clang \
+NVCCOPTSGDB = $(CUDACCOPTSDEBUG) -g -G --host-compilation='C++' \
-I../../common/inc -m64 \
-Xcompiler -arch -Xcompiler x86_64 -Xcompiler -stdlib=libstdc++ \
-gencode arch=compute_10,code=sm_10
-NVCCOPTSCUDAGDB = -g -G --host-compilation='C++' -ccbin /usr/bin/clang \
+NVCCOPTSCUDAGDB = -g -G --host-compilation='C++' \
-I../../common/inc -m64 \
-Xcompiler -arch -Xcompiler x86_64 -Xcompiler -stdlib=libstdc++ \
-gencode arch=compute_10,code=sm_10
#include <stdio.h>
#include <math.h>
#include "genUtil.h"
+#include "Matrix3D.h"
/* struct begin */
mrcPixelDataType mode,
mrcPixelDataHowToGet how);
+extern void mrcPixelsDataGet(float* data, mrcImageParaTypeRealCoord* inCoord, int nPixel, mrcImage* in, mrcPixelDataType type, mrcPixelDataHowToGet howto);
+extern void mrcPixelDataGetbyMatrix3D(mrcImage* out, mrcImage* in, Matrix3D mat, mrcPixelDataHowToGet mode, int mode2);
+
static inline double mrcPixelDataGetFloatImage(mrcImage* img,
mrcImageParaTypeInteger x, mrcImageParaTypeInteger y, mrcImageParaTypeInteger z)
{
#include <stdio.h>
#include <math.h>
#include "genUtil.h"
+#include "Matrix3D.h"
/* struct begin */
mrcPixelDataType mode,
mrcPixelDataHowToGet how);
+extern void mrcPixelsDataGet(float* data, mrcImageParaTypeRealCoord* inCoord, int nPixel, mrcImage* in, mrcPixelDataType type, mrcPixelDataHowToGet howto);
+extern void mrcPixelDataGetbyMatrix3D(mrcImage* out, mrcImage* in, Matrix3D mat, mrcPixelDataHowToGet mode, int mode2);
+
static inline double mrcPixelDataGetFloatImage(mrcImage* img,
mrcImageParaTypeInteger x, mrcImageParaTypeInteger y, mrcImageParaTypeInteger z)
{
lmrcSinogramFETnormalizedMap.h \
lmrcSinogramFETreferredCorrelation.h \
lmrcSinogramFETsmoothParameterMatching.h \
+mrcImageGetPixelsCUDA.h \
mrcImagePVM.h \
mrcImagefuncmin.h \
--- /dev/null
+/*
+# %M% %Y% %I%
+# The latest update : %G% at %U%
+#
+#%Z% mrcImageGetPixels ver %I%
+#%Z% Created by
+#%Z%
+#%Z% Usage : mrcImageGetPixels
+#%Z% Attention
+#%Z%
+*/
+static char __sccs_id[] = "%Z%mrcImageGetPixels ver%I%; Date:%D% %Z%";
+
+#define DEBUG
+#include "genUtil.h"
+#include "Memory.h"
+#include "eosCuda.h"
+#include "../inc/mrcImage.h"
+#include "./mrcImageGetPixelsCUDA.h"
+
+void
+mrcPixelsDataGet(float* data, mrcImageParaTypeRealCoord* inCoord, int nPixel, mrcImage* in, mrcPixelDataType type, mrcPixelDataHowToGet howto)
+{
+ int i;
+ double d;
+
+ DEBUGPRINT("mrcPixelsDataGet Start\n");
+ if(__eosCuda__) {
+#ifdef CUDA
+ if(sizeof(float)*3!=sizeof(mrcImageParaTypeRealCoord)) {
+ fprintf(stderr, "mrcImageParaTypeRealCoord is not float*3.\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("mrcImageParaTypeRealCoord is float*3.\n");
+ }
+ mrcPixelsDataGetCUDA(data, (float*)inCoord, nPixel, in->ImageFloatImage, in->HeaderMode, in->HeaderN.x, in->HeaderN.y, in->HeaderN.z, type, howto);
+#else
+ fprintf(stderr, "Not suppported CUDA\n");
+ exit(EXIT_FAILURE);
+#endif
+ } else {
+ for(i=0; i<nPixel; i++) {
+ mrcPixelDataGet(in, inCoord[i].x, inCoord[i].y, inCoord[i].z, &d, type, howto);
+ DEBUGPRINT4("%f %f %f : %f\n", inCoord[i].x, inCoord[i].y, inCoord[i].z, d);
+ data[i] = d;
+ }
+ }
+}
+
+void
+mrcPixelDataGetbyMatrix3D(mrcImage* out, mrcImage* in,
+ Matrix3D mat,
+ mrcPixelDataHowToGet mode, int mode2)
+{
+ mrcImageParaTypeReal srcx, srcy, srcz;
+ mrcImageParaTypeReal dstx, dsty, dstz;
+ mrcImageParaTypeReal gx, gy, gz;
+ floatVector v;
+ double data;
+ double offset;
+
+ out->Header = in->Header;
+ mrcInit(out, NULL);
+
+ floatVectorInit(&v, 4);
+ v.data[3] = 1;
+ gx = (in->HeaderN.x - 1)/2.0;
+ gy = (in->HeaderN.y - 1)/2.0;
+ gz = (in->HeaderN.z - 1)/2.0;
+
+ switch(mode2&0xf) {
+ case 1: {
+ offset = in->HeaderAMean;
+ break;
+ }
+ default: {
+ offset = 0.0;
+ break;
+ }
+ }
+
+ for(dstz=0; dstz<out->HeaderN.z; dstz++) {
+ for(dsty=0; dsty<out->HeaderN.y; dsty++) {
+ for(dstx=0; dstx<out->HeaderN.x; dstx++) {
+ v.data[0] = dstx - gx;
+ v.data[1] = dsty - gy;
+ v.data[2] = dstz - gz;
+ matrix3DMultiplyVector(&v, mat);
+
+ switch(mode2&0xf0) {
+ case 0:
+ if(SQR(v.data[0]/gx)+SQR(v.data[1]/gy)+SQR(v.data[2]/gz)<=1) {
+ srcx = v.data[0] + gx;
+ srcy = v.data[1] + gy;
+ srcz = v.data[2] + gz;
+ mrcPixelDataGet(in, srcx, srcy, srcz, &data, mrcPixelRePart, mode);
+ mrcPixelDataSet(out, dstx, dsty, dstz, data, mrcPixelRePart);
+ } else {
+ mrcPixelDataSet(out, dstx, dsty, dstz, offset, mrcPixelRePart);
+ }
+ break;
+ case 16:
+ srcx = v.data[0] + gx;
+ srcy = v.data[1] + gy;
+ srcz = v.data[2] + gz;
+ mrcPixelDataGet(in, srcx, srcy, srcz, &data, mrcPixelRePart, mode);
+ mrcPixelDataSet(out, dstx, dsty, dstz, data, mrcPixelRePart);
+ break;
+
+ }
+ }
+ }
+ }
+}
--- /dev/null
+/*
+# %M% %Y% %I%
+# The latest update : %G% at %U%
+#
+#%Z% mrcImageGetPixelsCUDA.cu ver %I%
+#%Z% Created by
+#%Z%
+#%Z% Usage : mrcImageGetPixelsCUDA.cu
+#%Z% Attention
+#%Z%
+*/
+static char __sccs_id[] = "%Z%mrcImageGetPixelsCUDA.cu ver%I%; Date:%D% %Z%";
+
+#include <stdio.h>
+#include <cuda.h>
+#define DEBUG
+#include "genUtil.h"
+#include "eosCuda.h"
+#include "../inc/mrcImage.h"
+#include "./mrcImageGetPixelsCUDA.h"
+
+
+__device__ float mrcPixelDataGetDevice(float x, float y, float z, float* inD, int nx, int ny, int nz, mrcPixelDataHowToGet howToMode)
+{
+ float data;
+
+ switch(howToMode) {
+ case mrcPixelHowNearest: {
+ int ix, iy, iz;
+ int n;
+ ix = (int)(x+0.5);
+ iy = (int)(y+0.5);
+ iz = (int)(z+0.5);
+
+ n = ix + iy*nx + iz*nx*ny;
+ data = inD[n];
+ break;
+ }
+ case mrcPixelHowLinear: {
+ int ix0, iy0, iz0;
+ int ix1, iy1, iz1;
+
+ if(1<ny && 1<nz) { // 3D
+ int n000, n001, n010, n011;
+ int n100, n101, n110, n111;
+ float data000, data010, data100, data110;
+ float data001, data011, data101, data111;
+
+ ix0 = (int)x;
+ iy0 = (int)y;
+ iz0 = (int)z;
+ ix1 = ix0+1;
+ iy1 = iy0+1;
+ iz1 = iz0+1;
+
+ n000 = ix0 + iy0*nx + iz0*nx*ny;
+ n010 = ix0 + iy1*nx + iz0*nx*ny;
+ n100 = ix1 + iy0*nx + iz0*nx*ny;
+ n110 = ix1 + iy1*nx + iz0*nx*ny;
+ n001 = ix0 + iy0*nx + iz1*nx*ny;
+ n011 = ix0 + iy1*nx + iz1*nx*ny;
+ n101 = ix1 + iy0*nx + iz1*nx*ny;
+ n111 = ix1 + iy1*nx + iz1*nx*ny;
+
+ data000 = inD[n000];
+ data010 = inD[n010];
+ data100 = inD[n100];
+ data110 = inD[n110];
+ data001 = inD[n001];
+ data011 = inD[n011];
+ data101 = inD[n101];
+ data111 = inD[n111];
+
+ data = (ix1 - x )*(iy1 - y )*(iz1 - z )*data000
+ + (ix1 - x )*(y - iy0)*(iz1 - z )*data010
+ + (x - ix0)*(iy1 - y )*(iz1 - z )*data100
+ + (x - ix0)*(y - iy0)*(iz1 - z )*data110
+ + (ix1 - x )*(iy1 - y )*(z - iz0)*data001
+ + (ix1 - x )*(y - iy0)*(z - iz0)*data011
+ + (x - ix0)*(iy1 - y )*(z - iz0)*data101
+ + (x - ix0)*(y - iy0)*(z - iz0)*data111;
+
+ } else if(1<ny) { // 2D
+ int n00, n01, n10, n11;
+ float data00, data01, data10, data11;
+
+ ix0 = (int)x;
+ iy0 = (int)y;
+ ix1 = ix0+1;
+ iy1 = iy0+1;
+
+ n00 = ix0 + iy0*nx;
+ n01 = ix0 + iy1*nx;
+ n10 = ix1 + iy0*nx;
+ n11 = ix1 + iy1*nx;
+
+ data00 = inD[n00];
+ data01 = inD[n01];
+ data10 = inD[n10];
+ data11 = inD[n11];
+
+ data = (ix1 - x )*(iy1 - y )*data00
+ + (ix1 - x )*(y - iy0)*data01
+ + (x - ix0)*(iy1 - y )*data10
+ + (x - ix0)*(y - iy0)*data11;
+ } else { // 1D
+ int n0, n1;
+ float data0, data1;
+
+ ix0 = (int)x;
+ ix1 = ix0+1;
+
+ n0 = ix0;
+ n1 = ix1;
+ data0 = inD[n0];
+ data1 = inD[n1];
+
+ data = (ix1 - x )*data0
+ + (x - ix0)*data1;
+ }
+ break;
+ }
+ case mrcPixelHowCubicConv: {
+ break;
+ }
+ case mrcPixelHowPolySig: {
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+
+ return data;
+}
+
+__global__ void mrcPixelsDataGetKernel(float* outD, float* inCoordD, int num, float* inD, int nx, int ny, int nz, mrcPixelDataHowToGet howToMode)
+{
+ int offset = threadIdx.x + blockIdx.x*blockDim.x;
+
+ if(offset<num) {
+ float x, y, z;
+
+ x = inCoordD[3*offset+0];
+ y = inCoordD[3*offset+1];
+ z = inCoordD[3*offset+2];
+
+ outD[offset] = mrcPixelDataGetDevice(x, y, z, inD, nx, ny, nz, howToMode);
+ }
+}
+
+__global__ void mrcPixelDataGetbyMatrix3DKernel(float* outD, float* matD, float* inD, int nx, int ny, int nz, mrcPixelDataHowToGet howToMode)
+{
+ int offset = threadIdx.x + blockIdx.x*blockDim.x;
+ int num = nx*ny*nz;
+
+ if(offset<num) {
+ float dstx, dsty, dstz;
+ float srcx, srcy, srcz;
+ float x, y, z;
+
+ // offset = dstx + dsty*nx + dstz*nx*ny; // 3D
+ // offset = dstx + dsty*nx; // 2D
+ // offset = dstx ; // 1D
+ if(1<ny && 1<nz) { // 3D
+ dstz = offset/(nx*ny);
+ dsty = (offset - dstz*nx*ny)/nx;
+ dstx = (offset - dstz*nx*ny - dsty*nx);
+ } else if(1<ny) { // 2D
+ dstz = 0;
+ dsty = offset/nx;
+ dstx = offset%nx;
+ } else { // 1D
+ dstz = 0;
+ dsty = 0;
+ dstx = offset;
+ }
+ x = dstx - matD[3*4 + 0];
+ y = dsty - matD[3*4 + 1];
+ z = dstz - matD[3*4 + 2];
+ srcx = matD[0*4+0]*x + matD[0*4+1]*y + matD[0*4+2]*z;
+ srcy = matD[1*4+0]*x + matD[1*4+1]*y + matD[1*4+2]*z;
+ srcz = matD[2*4+0]*x + matD[2*4+1]*y + matD[2*4+2]*z;
+ outD[offset] = mrcPixelDataGetDevice(srcx, srcy, srcz, inD, nx, ny, nz, howToMode);
+ }
+}
+
+
+void
+mrcPixelsDataGetCUDA(float* out, float* inCoord, int num, float* in, mrcImageMode imageMode, int nx, int ny, int nz, mrcPixelDataType type, mrcPixelDataHowToGet howToMode)
+{
+ cudaError_t err = cudaSuccess;
+ int nPixel = nx*ny*nz;
+
+ DEBUGPRINT("mrcPixelsDataGetCUDA start ----> \n");
+
+ switch(imageMode) {
+ case mrcFloatImage: {
+ float* inD;
+ float* outD;
+ float* inCoordD;
+
+ // inD
+ DEBUGPRINT3("%d %p -> %p\n", nPixel, in, out);
+ err = cudaMalloc((void **)&inD, sizeof(float)*nPixel);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "Memory Not Allocated\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMalloc\n");
+ }
+ // outD
+ err = cudaMalloc((void **)&outD, sizeof(float)*num);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "Memory Not Allocated\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMalloc\n");
+ }
+ // inCoordD
+ err = cudaMalloc((void **)&inCoordD, sizeof(float)*num*3);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "Memory Not Allocated\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMalloc\n");
+ }
+
+ // in -> inD
+ cudaMemcpy(inD, in, sizeof(float)*nPixel, cudaMemcpyHostToDevice);
+ // inCoord -> inD
+ cudaMemcpy(inCoordD, inCoord, sizeof(float)*3*num, cudaMemcpyHostToDevice);
+
+ if(err != cudaSuccess) {
+ fprintf(stderr, "cudaMemcpy\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMemcpy: HostToDevice\n");
+ }
+ mrcPixelsDataGetKernel<<<num/__eosCudaThreadsPerBlock__,__eosCudaThreadsPerBlock__>>>(outD, inCoordD, num, inD, nx, ny, nz, howToMode);
+
+ cudaMemcpy(out, outD, sizeof(float)*num, cudaMemcpyDeviceToHost);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "cudaMemcpy\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMemcpy: DeviceToHost\n");
+ }
+ cudaFree(inD);
+ cudaFree(inCoordD);
+ cudaFree(outD);
+ break;
+ }
+ default: {
+ fprintf(stderr, "Not supported mode in mrcPixelDataGetCUDA: %d\n", imageMode);
+ exit(EXIT_FAILURE);
+ break;
+ }
+ }
+}
+
+
+void
+mrcPixelDataGetbyMatrix3DCUDA(float* out, float* mat, float* in, mrcImageMode imageMode, int nx, int ny, int nz, mrcPixelDataType type, mrcPixelDataHowToGet howToMode)
+{
+ cudaError_t err = cudaSuccess;
+ int nPixel = nx*ny*nz;
+
+ switch(imageMode) {
+ case mrcFloatImage: {
+ float* inD;
+ float* outD;
+ float* matD;
+
+ // inD
+ DEBUGPRINT3("%d %p -> %p\n", nPixel, in, out);
+ err = cudaMalloc((void **)&inD, sizeof(float)*nPixel);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "Memory Not Allocated\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMalloc\n");
+ }
+ // outD
+ err = cudaMalloc((void **)&outD, sizeof(float)*nPixel);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "Memory Not Allocated\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMalloc\n");
+ }
+ // matD
+ err = cudaMalloc((void **)&matD, sizeof(float)*4*4);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "Memory Not Allocated\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMalloc\n");
+ }
+
+ // in -> inD
+ cudaMemcpy(inD, in, sizeof(float)*nPixel, cudaMemcpyHostToDevice);
+ // inCoord -> inD
+ cudaMemcpy(matD, mat, sizeof(float)*4*4, cudaMemcpyHostToDevice);
+
+ if(err != cudaSuccess) {
+ fprintf(stderr, "cudaMemcpy\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMemcpy: HostToDevice\n");
+ }
+ mrcPixelDataGetbyMatrix3DKernel<<<nPixel/__eosCudaThreadsPerBlock__,__eosCudaThreadsPerBlock__>>>(outD, matD, inD, nx, ny, nz, howToMode);
+
+ cudaMemcpy(out, outD, sizeof(float)*nPixel, cudaMemcpyDeviceToHost);
+ if(err != cudaSuccess) {
+ fprintf(stderr, "cudaMemcpy\n");
+ exit(EXIT_FAILURE);
+ } else {
+ DEBUGPRINT("Success cudaMemcpy: DeviceToHost\n");
+ }
+ cudaFree(inD);
+ cudaFree(matD);
+ cudaFree(outD);
+ break;
+ }
+ default: {
+ fprintf(stderr, "Not supported mode in mrcPixelDataGetCUDA: %d\n", imageMode);
+ exit(EXIT_FAILURE);
+ break;
+ }
+ }
+
+}
+
--- /dev/null
+/*
+# mrcImageGetPixelsCUDA.h : $Revision$
+# $Date$
+# Created by $Author$
+# Usage : mrcImageGetPixelsCUDA.h
+# Attention
+# $Loccker$
+# $State$
+#
+*/
+/* $Log$ */
+#ifndef MRCIMAGE_GET_PIXELS_CUDA_H
+#define MRCIMAGE_GET_PIXELS_CUDA_H
+
+#include <stdio.h>
+
+/* constant begin */
+
+
+/* constant end */
+
+/* struct begin */
+
+
+/* struct end */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* prototype begin */
+
+extern void mrcPixelsDataGetCUDA(float* out, float* inCoord, int num, float* in, mrcImageMode imageMode, int nx, int ny, int nz, mrcPixelDataType type, mrcPixelDataHowToGet howToMode);
+
+
+extern void mrcPixelDataGetbyMatrix3DCUDA(float* out, float* mat, float* in, mrcImageMode imageMode, int nx, int ny, int nz, mrcPixelDataType type, mrcPixelDataHowToGet howToMode);
+
+
+/* prototype end */
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* MRCIMAGE_GET_PIXELS_CUDA_H */
WORLDNAME=Tools
WORLDNAME=Tools
WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
OBJECTNAME = mrcImagePixelDataGet
-EXTRA_LIB =
+EXTRA_LIB = $(LIBCUDA)
EXTRA_CCOPTS =
EXTRA_INC =
# OptionControlFile
# FileFormat
-"-i","-i[nput]","InputDataFile","Essential","1","1","In","inFile","NULL"
-"-o","-o[utput]","OutputDataFile","Optional","1","1","Out","outFile","stdout"
+"-i","-i[nput]","Input: mrcImage","Essential","1","1","In","inFile::mrcImage","NULL"
+"-o","-o[utput]","OutputDataFile","Optional","1","1","Out","outFile::ASCII","stdout"
"-x","-x","Input: x","Optional","1","1","x","Real","0.0"
"-y","-y","Input: y","Optional","1","1","y","Real","0.0"
"-z","-z","Input: z","Optional","1","1","z","Real","0.0"
+"-In","-In[put]","Input:eosPoint","Optional","1","1","InCoord","inFile::ASCII","stdin"
+"-cuda","-cuda","cudaDeviceID","Optional","1","1","cudaDeviceID","Integer","0"
"-c","-c[onfig]","ConfigurationFile","Optional","1","1","configFile","inFile","NULL"
"-m","-m[ode]","Mode","Optional","1","1","mode","Integer","0"
+++ /dev/null
-include ../../../Config/Define.inc
-include ../../Config/Define.inc
-include ../Config/Define.inc
-include Config/Define.inc
-
-all:
- cd src; make all; cd ..
-
-install:
- cd src; make install; cd ..
-
-
-putSF:
- if [ -f private ] ; \
- then \
- echo "$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME) is private"; \
- else \
- cvs -z4 -d:ext:$$USER@$$EOS_SOURCEFORGE commit || cvs -z4 -d:ext:$$USER@$$EOS_SOURCEFORGE import src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME); \
- fi
-
-put:
- cd src; make put; cd ..
-
-clean:
- cd src; make clean; cd ..
-
-depend:
- cd src; make depend; cd ..
-
-check:
- @if [ ! -d $(EOS_HOME)/hostdepend/$(OSTYPE)/src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/$(OSTYPE) ] ; then \
- echo making directory; \
- mkdir -p $(EOS_HOME)/hostdepend/$(OSTYPE)/src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/$(OSTYPE); \
- fi
- ln -sf ../../../../../hostdepend/$(OSTYPE)/src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/$(OSTYPE) src/$(OSTYPE);
- @$(RM) src/Makefile
- @echo "New src/Makefile"
- @$(CP) ../../../Config/Template/$(WORLDNAME)Template.Dir/src/Makefile src/Makefile
- @cd src; touch $(OSTYPE)/.Depend; make depend
-
-cvsupdate::
- cvs -d $(EOS_CVSROOT) update -d
-
-cvscommit::
- cvs -d $(EOS_CVSROOT) commit
-
-backup:
- @cd ../../../..; \
- echo $(OBJECTNAME) ; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Config ; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Makefile ;\
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/.[A-z]* ; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/inc ; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/doc; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/wish; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/[A-z]*.[A-z]*; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/.[A-z]*; \
- tar uvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/Makefile
-
-backup-all:
- @cd ../../../..; \
- echo $(OBJECTNAME) ; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Config ; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Makefile ;\
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/.[A-z]* ; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/inc ; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/doc; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/wish; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/[A-z]*.[A-z]*; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/.[A-z]*; \
- tar rvf ${EOS_HOME}/backup/EosBase.tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/Makefile
-
-distribute:
- cd ../../../..; \
- echo $(OBJECTNAME) ; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Config ; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Makefile ;\
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/.[A-z]* ; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/inc ; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/doc; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/wish; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/[A-z]*.[A-z]*; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/.[A-z]*; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/Makefile ; \
- tar uvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/$(OSTYPE)
-
-distribute-all:
- @cd ../../../..; \
- echo $(OBJECTNAME) ; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Config ; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/Makefile ;\
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/.[A-z]* ; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/inc ; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/doc; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/wish; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/[A-z]*.[A-z]*; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/.[A-z]*; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/Makefile ; \
- tar rvf ${EOS_HOME}/distribute/src.$(OSTYPE).tar src/$(WORLDNAME)/$(CLASSNAME)/$(OBJECTNAME)/src/$(OSTYPE)
-
-eosintroduce:
- ${EOS_HOME}/sbin/eosintroduce ${WORLDNAME} ${CLASSNAME} ${OBJECTNAME} ./
-
-include Config/Target.inc
--- /dev/null
+/Users/tacyas/Eos/src/Config/Template/ToolsTemplate.Dir/Makefile
\ No newline at end of file
-/home/people/tacyas/Eos/src/Config/Template/ToolsTemplate.Dir/doc/Makefile
\ No newline at end of file
+/Users/tacyas/Eos/src/Config/Template/ToolsTemplate.Dir/doc/Makefile
\ No newline at end of file
long flagz;
float z;
+ long flagInCoord;
+ char* InCoord;
+ FILE* fptInCoord;
+
+ long flagcudaDeviceID;
+ long cudaDeviceID;
+
long flagconfigFile;
char* configFile;
FILE* fptconfigFile;
void
argCheck(mrcImagePixelDataGetInfo* info, int argc, char* argv[])
{
- long i, j, nv;
+ long i;
char s[1024];
FILE* fpt;
}
SBREAK;
}
+ SCASE("In") {
+ if(i+1<argc) {
+ info->InCoord = stringGetNthWord(argv[i+1], 1, " ,");
+ i++;
+ info->flagInCoord++;
+ } else {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ SBREAK;
+ }
+ SCASE("cuda") {
+ if(i+1<argc) {
+ info->cudaDeviceID = stringGetNthIntegerData(argv[i+1], 1, " ,");
+ i++;
+ info->flagcudaDeviceID++;
+ } else {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ SBREAK;
+ }
SCASE("c") {
if(i+1<argc) {
info->configFile = stringGetNthWord(argv[i+1], 1, " ,");
info->x = 0.0; info->flagx = 0;
info->y = 0.0; info->flagy = 0;
info->z = 0.0; info->flagz = 0;
+ info->fptInCoord = stdin; info->flagInCoord = 0;
+ info->cudaDeviceID = 0; info->flagcudaDeviceID = 0;
info->fptconfigFile = NULL; info->flagconfigFile = 0;
info->mode = 0; info->flagmode = 0;
}
int i;
if(!info->flagIn) {
stringGetFromFile(s, "In", stdin, stdout, 0);
- info->In = stringGetNthWord(s, 1, " ,");
+ info->In = stringGetNthWord(s, 1, " ,\t");
info->flagIn++;
}
if(info->flagIn) {
if(info->flagz) {
}
+ if(info->flagInCoord) {
+ info->fptInCoord = fileOpen(info->InCoord, "r");
+ }
+
+ if(info->flagcudaDeviceID) {
+ }
+
if(info->flagconfigFile) {
info->fptconfigFile = fileOpen(info->configFile, "r");
}
#define DEBUG
#include "genUtil.h"
+#include "Memory.h"
#include "mrcImage.h"
+#include "eosPoint.h"
+
+#ifdef CUDA
+#include "eosCuda.h"
+#endif
+
/*
Example:
mrcImagePixelDataGetInfo info;
mrcImage in;
double data;
+ float* dataArray;
+ mrcImageParaTypeRealCoord* inCoord;
+ int nPixel, i;
+ eosPoint p;
init0(&info);
argCheck(&info, argc, argv);
init1(&info);
DEBUGPRINT("Program Start\n");
+#ifdef CUDA
+ if(info.flagcudaDeviceID) {
+ DEBUGPRINT("eosCudaInit --> start\n");
+ eosCudaInit(info.cudaDeviceID);
+ DEBUGPRINT("eosCudaInit --> end\n");
+ }
+#endif
mrcFileRead(&in, info.In, "in main", 0);
- mrcPixelDataGet(&in, info.x, info.y, info.z, &data, mrcPixelRePart, mrcPixelHowNearest);
+ if(info.flagInCoord) {
+ eosPointRead(info.fptInCoord, &p, 0);
+ nPixel=0;
+ p.current = p.top;
+ while(p.current!=NULL) {
+ nPixel++;
+ p.current = p.current->next;
+ }
+ dataArray = memoryAllocate(sizeof(float)*nPixel, "in mrcPixelsDataGet");
+ inCoord = memoryAllocate(sizeof(mrcImageParaTypeRealCoord)*nPixel, "in mrcPixelsDataGet");
- fprintf(info.fptOut, "%lf", data);
+ i = 0;
+ p.current = p.top;
+ while(p.current!=NULL) {
+ inCoord[i].x = p.current->p.coord.data[0];
+ inCoord[i].y = p.current->p.coord.data[1];
+ inCoord[i].z = p.current->p.coord.data[2];
+ i++;
+ p.current = p.current->next;
+ }
+ mrcPixelsDataGet(dataArray, inCoord, nPixel, &in, mrcPixelRePart, info.mode);
+ for(i=0; i<nPixel; i++) {
+ fprintf(info.fptOut, "%f\n", dataArray[i]);
+ }
+ } else {
+ mrcPixelDataGet(&in, info.x, info.y, info.z, &data, mrcPixelRePart, info.mode);
+ fprintf(info.fptOut, "%lf\n", data);
+ }
exit(EXIT_SUCCESS);
}
-/bin/bash: mrcImagePixelDataGet: そのようなファイルやディレクトリはありません
+<HTML>
+<HEAD>
+<TITLE>mrcImagePixelDataGet</TITLE>
+</HEAD>
+<BODY>
+<H1>mrcImagePixelDataGet</H1>
+<H2>Usage</H2>
+<PRE>
+Usage: mrcImagePixelDataGet
+Options:
+ [-i[nput] In (NULL ).as(inFile::mrcImage ) ] :Essential :Input: mrcImage
+ [-o[utput] Out (stdout ).as(outFile::ASCII ) ] :Optional :OutputDataFile
+ [-x x (0.0 ).as(Real ) ] :Optional :Input: x
+ [-y y (0.0 ).as(Real ) ] :Optional :Input: y
+ [-z z (0.0 ).as(Real ) ] :Optional :Input: z
+ [-In[put] InCoord (stdin ).as(inFile::ASCII ) ] :Optional :Input:eosPoint
+ [-cuda cudaDeviceID (0 ).as(Integer ) ] :Optional :cudaDeviceID
+ [-c[onfig] configFile (NULL ).as(inFile ) ] :Optional :ConfigurationFile
+ [-m[ode] mode (0 ).as(Integer ) ] :Optional :Mode
+----- Additional Usage -----
+</PRE>
+</BODY>
+</HTML>
-R 1 0 1 5x1+35+0 'Run' 'execute operation' $EOS/bin/mrcImagePixelDataGet
-H 1 5x1+41+0 'Help' 'help page' $EOS/src/Tools/mrcImage/mrcImagePixelDataGet/doc/mrcImagePixelDataGet.doc help
-Q 1 0 5.25x1+47+0 'Close'
- -I 1 0 1 1 0 1 -1x1+1+1.500000 ' ' 'In' 'InputDataFile' i
+ -I 1 0 1 1 0 1 -1x1+1+1.500000 ' ' 'In' 'Input: mrcImage' i
-O 1 0 1 0 0 1 -1x1+1+3.000000 ' ' 'Out' 'OutputDataFile' o
-f 1 0 1 0 0 -1x1+1+4.500000 0 0 0.000000 0 0 0 'x' 'Input: x' x
-f 1 0 1 0 0 -1x1+1+6.000000 0 0 0.000000 0 0 0 'y' 'Input: y' y
-f 1 0 1 0 0 -1x1+1+7.500000 0 0 0.000000 0 0 0 'z' 'Input: z' z
- -I 1 0 1 0 0 1 -1x1+1+9.000000 ' ' 'configFile' 'ConfigurationFile' c
- -i 1 0 1 0 0 -1x1+1+10.500000 0 0 0 0 0 'mode' 'Mode' m
+ -I 1 0 1 0 0 1 -1x1+1+9.000000 ' ' 'InCoord' 'Input:eosPoint' In
+ -i 1 0 1 0 0 -1x1+1+10.500000 0 0 0 0 0 'cudaDeviceID' 'cudaDeviceID' cuda
+ -I 1 0 1 0 0 1 -1x1+1+12.000000 ' ' 'configFile' 'ConfigurationFile' c
+ -i 1 0 1 0 0 -1x1+1+13.500000 0 0 0 0 0 'mode' 'Mode' m
-E
-E
-E
--- /dev/null
+include ../../Config/Define.inc
+include ../../../Config/Define.inc
+include ../../../../Config/Define.inc
+include ../../../../../Config/Define.inc
+
+all: help exec
+
+help:
+ @echo "----- Help Message Check -----"
+ @../$(OSTYPE)/$(OBJECTNAME) -h
+
+exec:
+ @echo "----- Execution Check -----"
+ ../$(OSTYPE)/$(OBJECTNAME) -i data/test.in -o data/test.out1 -x 128 -y 128 -z 0 -m 0
+ ../$(OSTYPE)/$(OBJECTNAME) -i data/test.in -o data/test.out2 -x 128.2 -y 128.2 -z 0 -m 1
+ ../$(OSTYPE)/$(OBJECTNAME) -i data/test.in -o data/test.out3 -In data/test.inCoord -m 0
+ ../$(OSTYPE)/$(OBJECTNAME) -i data/test.in -o data/test.out4 -In data/test.inCoord -m 1
+ ../$(OSTYPE)/$(OBJECTNAME) -i data/test.in -o data/test.out5 -In data/test.inCoord -m 0 -cuda 0
+ ../$(OSTYPE)/$(OBJECTNAME) -i data/test.in -o data/test.out6 -In data/test.inCoord -m 1 -cuda 0
+ @echo "----- Calc check -----"
+
+clean:
--- /dev/null
+../../../../../..//data/mrcImagePixelDataGet
\ No newline at end of file
{
fprintf(stderr, "Usage: %s\n", thisProgram);
fprintf(stderr, "Options:\n");
- fprintf(stderr, " [-i[nput] In (NULL )] :Essential :InputDataFile\n");
- fprintf(stderr, " [-o[utput] Out (stdout )] :Optional :OutputDataFile\n");
- fprintf(stderr, " [-x x (0.0 )] :Optional :Input: x\n");
- fprintf(stderr, " [-y y (0.0 )] :Optional :Input: y\n");
- fprintf(stderr, " [-z z (0.0 )] :Optional :Input: z\n");
- fprintf(stderr, " [-c[onfig] configFile (NULL )] :Optional :ConfigurationFile\n");
- fprintf(stderr, " [-m[ode] mode (0 )] :Optional :Mode\n");
+ fprintf(stderr, " [-i[nput] In (NULL ).as(inFile::mrcImage ) ] :Essential :Input: mrcImage\n");
+ fprintf(stderr, " [-o[utput] Out (stdout ).as(outFile::ASCII ) ] :Optional :OutputDataFile\n");
+ fprintf(stderr, " [-x x (0.0 ).as(Real ) ] :Optional :Input: x\n");
+ fprintf(stderr, " [-y y (0.0 ).as(Real ) ] :Optional :Input: y\n");
+ fprintf(stderr, " [-z z (0.0 ).as(Real ) ] :Optional :Input: z\n");
+ fprintf(stderr, " [-In[put] InCoord (stdin ).as(inFile::ASCII ) ] :Optional :Input:eosPoint\n");
+ fprintf(stderr, " [-cuda cudaDeviceID (0 ).as(Integer ) ] :Optional :cudaDeviceID\n");
+ fprintf(stderr, " [-c[onfig] configFile (NULL ).as(inFile ) ] :Optional :ConfigurationFile\n");
+ fprintf(stderr, " [-m[ode] mode (0 ).as(Integer ) ] :Optional :Mode\n");
additionalUsage();
}
OSDN Git Service
