int main() {
int tstep;
char time_str[34];
time_t t0;
// Set the parameters
int Nx, Ny, Nz, TMAX;
Nx = 200;
Ny = 200;
Nz = 208;
TMAX = 100;
// Allocate host memory
float ***Ex, ***Ey, ***Ez;
float ***Hx, ***Hy, ***Hz;
float ***CEx, ***CEy, ***CEz;
Ex = makeArray(Nx, Ny, Nz);
Ey = makeArray(Nx, Ny, Nz);
Ez = makeArray(Nx, Ny, Nz);
Hx = makeArray(Nx, Ny, Nz);
Hy = makeArray(Nx, Ny, Nz);
Hz = makeArray(Nx, Ny, Nz);
CEx = makeArray(Nx, Ny, Nz);
CEy = makeArray(Nx, Ny, Nz);
CEz = makeArray(Nx, Ny, Nz);
// Geometry
set_geometry(Nx, Ny, Nz, CEx, CEy, CEz);
// Update on the CPU
t0 = time(0);
for ( tstep=1; tstep<=TMAX; tstep++) {
updateE(Nx, Ny, Nz, Ex, Ey, Ez, Hx, Hy, Hz, CEx, CEy, CEz);
updateSrc(Nx, Ny, Nz, Ex, tstep);
updateH(Nx, Ny, Nz, Ex, Ey, Ez, Hx, Hy, Hz);
if ( tstep/100*100 == tstep ) {
//dumpToH5(Nx, Ny, Nz, Nx/2, 0, 0, Nx/2, Ny-1, Nz-1, Ex, "cpu_png/Ex-%05d.h5", tstep);
//exec("h5topng -ZM0.1 -x0 -S4 -c /usr/share/h5utils/colormaps/dkbluered cpu_png/Ex-%05d.h5", tstep);
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
}
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
/**
* Performs digit and letter shaping.
*
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
* @param pErrorCode Pointer to the error code value.
*
* @return Whether or not this function modifies the text. Besides the return
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
*/
static UBool
action_shapeArabic(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
{
if ((pTransform->letters | pTransform->digits) == 0) {
return FALSE;
}
if (pTransform->pActiveScheme->lettersDir == pTransform->pActiveScheme->digitsDir) {
doShape(pTransform, pTransform->letters | pTransform->digits | pTransform->pActiveScheme->lettersDir,
pErrorCode);
} else {
doShape(pTransform, pTransform->digits | pTransform->pActiveScheme->digitsDir, pErrorCode);
if (U_SUCCESS(*pErrorCode)) {
updateSrc(pTransform, pTransform->dest, *pTransform->pDestLength,
*pTransform->pDestLength, pErrorCode);
doShape(pTransform, pTransform->letters | pTransform->pActiveScheme->lettersDir,
pErrorCode);
}
}
return TRUE;
}
U_DRAFT uint32_t U_EXPORT2
ubiditransform_transform(UBiDiTransform *pBiDiTransform,
const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
UBiDiLevel inParaLevel, UBiDiOrder inOrder,
UBiDiLevel outParaLevel, UBiDiOrder outOrder,
UBiDiMirroring doMirroring, uint32_t shapingOptions,
UErrorCode *pErrorCode)
{
uint32_t destLength = 0;
UBool textChanged = FALSE;
const UBiDiTransform *pOrigTransform = pBiDiTransform;
const UBiDiAction *action = NULL;
if (U_FAILURE(*pErrorCode)) {
return 0;
}
if (src == NULL || dest == NULL) {
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
CHECK_LEN(src, srcLength, pErrorCode);
CHECK_LEN(dest, destSize, pErrorCode);
if (pBiDiTransform == NULL) {
pBiDiTransform = ubiditransform_open(pErrorCode);
if (U_FAILURE(*pErrorCode)) {
return 0;
}
}
/* Current limitation: in multiple paragraphs will be resolved according
to the 1st paragraph */
resolveBaseDirection(src, srcLength, &inParaLevel, &outParaLevel);
pBiDiTransform->pActiveScheme = findMatchingScheme(inParaLevel, outParaLevel,
inOrder, outOrder);
if (pBiDiTransform->pActiveScheme == NULL) {
goto cleanup;
}
pBiDiTransform->reorderingOptions = doMirroring ? UBIDI_DO_MIRRORING
: UBIDI_REORDER_DEFAULT;
/* Ignore TEXT_DIRECTION_* flags, as we apply our own depending on the text
scheme at the time shaping is invoked. */
shapingOptions &= ~U_SHAPE_TEXT_DIRECTION_MASK;
pBiDiTransform->digits = shapingOptions & ~U_SHAPE_LETTERS_MASK;
pBiDiTransform->letters = shapingOptions & ~U_SHAPE_DIGITS_MASK;
updateSrc(pBiDiTransform, src, srcLength, destSize > srcLength ? destSize : srcLength, pErrorCode);
if (U_FAILURE(*pErrorCode)) {
goto cleanup;
}
if (pBiDiTransform->pBidi == NULL) {
pBiDiTransform->pBidi = ubidi_openSized(0, 0, pErrorCode);
if (U_FAILURE(*pErrorCode)) {
goto cleanup;
}
}
pBiDiTransform->dest = dest;
pBiDiTransform->destSize = destSize;
pBiDiTransform->pDestLength = &destLength;
/* Checking for U_SUCCESS() within the loop to bail out on first failure. */
for (action = pBiDiTransform->pActiveScheme->actions; *action && U_SUCCESS(*pErrorCode); action++) {
if ((*action)(pBiDiTransform, pErrorCode)) {
if (action + 1) {
updateSrc(pBiDiTransform, pBiDiTransform->dest, *pBiDiTransform->pDestLength,
*pBiDiTransform->pDestLength, pErrorCode);
}
textChanged = TRUE;
}
}
ubidi_setInverse(pBiDiTransform->pBidi, FALSE);
if (!textChanged && U_SUCCESS(*pErrorCode)) {
/* Text was not changed - just copy src to dest */
if (destSize < srcLength) {
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
} else {
u_strncpy(dest, src, srcLength);
destLength = srcLength;
}
}
cleanup:
if (pOrigTransform != pBiDiTransform) {
ubiditransform_close(pBiDiTransform);
} else {
pBiDiTransform->dest = NULL;
pBiDiTransform->pDestLength = NULL;
pBiDiTransform->srcLength = 0;
pBiDiTransform->destSize = 0;
}
return U_FAILURE(*pErrorCode) ? 0 : destLength;
}
int main() {
int i,j,k;
int tstep;
char time_str[32];
time_t t0;
// Set the parameters
N3 N;
N.x = 300;
N.y = 300;
//N.z = 304;
N.z = 224;
int TMAX = 100;
float S = 0.5;
float dx = 10e-9;
float dt = S*dx/light_velocity;
printf("N(%d,%d,%d), TMAX=%d\n", N.x, N.y, N.z, TMAX);
// Allocate host memory
P3F3 E, H, CE, CH;
E.x = makeArray3D( N.x, N.y, N.z );
E.y = makeArray3D( N.x, N.y, N.z );
E.z = makeArray3D( N.x, N.y, N.z );
H.x = makeArray3D( N.x, N.y, N.z );
H.y = makeArray3D( N.x, N.y, N.z );
H.z = makeArray3D( N.x, N.y, N.z );
CE.x = makeArray3D( N.x, N.y, N.z );
CE.y = makeArray3D( N.x, N.y, N.z );
CE.z = makeArray3D( N.x, N.y, N.z );
CH.x = makeArray3D( N.x, N.y, N.z );
CH.y = makeArray3D( N.x, N.y, N.z );
CH.z = makeArray3D( N.x, N.y, N.z );
// Geometry
for (i=0; i<N.x; i++) {
for (j=0; j<N.y; j++) {
for (k=0; k<N.z; k++) {
CE.x[i][j][k] = 0.5;
CE.y[i][j][k] = 0.5;
CE.z[i][j][k] = 0.5;
if ( i == N.x-1 ) {
CE.y[i][j][k] = 0;
CE.z[i][j][k] = 0;
}
if ( j == N.y-1 ) {
CE.z[i][j][k] = 0;
CE.x[i][j][k] = 0;
}
if ( k == N.z-1 ) {
CE.x[i][j][k] = 0;
CE.y[i][j][k] = 0;
}
CH.x[i][j][k] = 0.5;
CH.y[i][j][k] = 0.5;
CH.z[i][j][k] = 0.5;
if ( i == 0 ) {
CH.y[i][j][k] = 0;
CH.z[i][j][k] = 0;
}
if ( j == 0 ) {
CH.z[i][j][k] = 0;
CH.x[i][j][k] = 0;
}
if ( k == 0 ) {
CH.x[i][j][k] = 0;
CH.y[i][j][k] = 0;
}
}
}
}
t0 = time(0);
for ( tstep=1; tstep<=TMAX; tstep++ ) {
updateE( N, E, H, CE );
updateSrc( N, E, tstep );
updateH( N, E, H, CH );
/*
if ( tstep/50*50 == tstep ) {
dumpToH5(N.x, N.y, N.z, N.x/2, 0, 0, N.x/2, N.y-1, N.z-1, E.x, "cpu_png/Ex-%05d.h5", tstep);
exec("h5topng -ZM0.1 -x0 -S4 -c /usr/share/h5utils/colormaps/dkbluered cpu_png/Ex-%05d.h5", tstep);
//dumpToH5(N.x, N.y, N.z, 0, 0, N.z/2, N.x-1, N.y-1, N.z/2, E.z, "cpu_png/Ez-%05d.h5", tstep);
//exec("h5topng -ZM0.1 -z0 -S4 -c /usr/share/h5utils/colormaps/dkbluered cpu_png/Ez-%05d.h5", tstep);
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
*/
}
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
void applySrcCallBack(int pos){
if( pos ){
cvCopy(dst,src);
updateSrc();
}
}
int main(int argc, char **argv){
assert (argc == 2);
init_values();
src_org = cvLoadImage(argv[1]);
//aloca memoria para origem "dinamica" para acontecer esta ser uma origem acumulativa!
src = cvCreateImage(cvGetSize(src_org),src_org->depth,src_org->nChannels);
cvCopy(src_org,src);
//cvNamedWindow("src-org");
//cvShowImage("src-org",src_org);
cvNamedWindow("src");
updateSrc();
cvNamedWindow("dst");
cvNamedWindow("config");
cvNamedWindow("config2");
int x = 30;
int y = 50;
int offset = 10;
cvMoveWindow("src",x,y);
cvMoveWindow("dst",x+offset+cvGetSize(src).width,y);
cvMoveWindow("config",670,y);
cvMoveWindow("config2",1000,y);
cvCreateTrackbar("gaussian","config",&gaussian_value,gaussian_max,gaussianCallBack);
cvCreateTrackbar("canny-low","config",&canny_low_value,canny_low_max,NULL);
cvCreateTrackbar("canny-high","config",&canny_high_value,canny_high_max,NULL);
cvCreateTrackbar("canny-en","config",&canny_enable,1,cannyCallBack);
cvCreateTrackbar("hough-minDist","config",&hough_minDist_value,hough_minDist_max,NULL);
cvCreateTrackbar("hough-param1","config",&hough_param1_value,hough_param1_max,NULL);
cvCreateTrackbar("hough-param2","config",&hough_param2_value,hough_param2_max,NULL);
cvCreateTrackbar("hough-minRadius","config",&hough_minRadius_value,hough_minRadius_max,NULL);
cvCreateTrackbar("hough-maxRadius","config",&hough_maxRadius_value,hough_maxRadius_max,NULL);
cvCreateTrackbar("hough-en","config",&hough_enable,1,houghCallBack);
cvCreateTrackbar("apply","config",&apply_value,1,applySrcCallBack);
cvCreateTrackbar("hue-min","config2",&hue_min_value,hue_max,NULL);
cvCreateTrackbar("hue-max","config2",&hue_max_value,hue_max,NULL);
cvCreateTrackbar("sat-min","config2",&sat_min_value,sat_max,NULL);
cvCreateTrackbar("sat-max","config2",&sat_max_value,sat_max,NULL);
cvCreateTrackbar("val-min","config2",&val_min_value,val_max,NULL);
cvCreateTrackbar("val-max","config2",&val_max_value,val_max,NULL);
// HSV color picker na janela SRC
cvSetMouseCallback("src",mouseCallBack,(void*)src);
// loop central... ESQ finaliza!
while(true){
if(cvWaitKey(10) == 27) break;
}
cvDestroyWindow("src");
//cvDestroyWindow("src-org");
cvDestroyWindow("dst");
cvDestroyWindow("config");
cvDestroyWindow("config2");
cvReleaseImage(&src_org);
cvReleaseImage(&src);
cvReleaseImage(&dst);
}
int main() {
int i;
int tstep;
char time_str[32];
time_t t0;
// Set the parameters
N3 N;
N.x = 250;
N.y = 250;
N.z = 320;
int TMAX = 1000;
float S = 0.5;
float dx = 10e-9;
float dt = S*dx/light_velocity;
printf("N(%d,%d,%d), TMAX=%d\n", N.x, N.y, N.z, TMAX);
printf("NPML=%d\n", Npml);
// Allocate host memory
P3F3 E, H, CE;
E.x = makeArray3D( N.x, N.y, N.z );
E.y = makeArray3D( N.x, N.y, N.z );
E.z = makeArray3D( N.x, N.y, N.z );
H.x = makeArray3D( N.x, N.y, N.z );
H.y = makeArray3D( N.x, N.y, N.z );
H.z = makeArray3D( N.x, N.y, N.z );
CE.x = makeArray3D( N.x, N.y, N.z );
CE.y = makeArray3D( N.x, N.y, N.z );
CE.z = makeArray3D( N.x, N.y, N.z );
// Geometry
set_geometry( N, CE );
/*
// CPML
int m = 4; // grade_order
float sigma_max = (m+1.)/(15*pi*Npml*dx);
float alpha = 0.05;
float *sigmaE, *bE, *aE;
float *sigmaH, *bH, *aH;
sigmaE = (float *) calloc (2*Npml, sizeof(float));
sigmaH = (float *) calloc (2*Npml, sizeof(float));
bE = (float *) calloc (2*Npml, sizeof(float));
bH = (float *) calloc (2*Npml, sizeof(float));
aE = (float *) calloc (2*Npml, sizeof(float));
aH = (float *) calloc (2*Npml, sizeof(float));
for (i=0; i<Npml; i++) {
sigmaE[i] = pow( (Npml-0.5-i)/Npml, m )*sigma_max;
sigmaE[i+Npml] = pow( (0.5+i)/Npml, m )*sigma_max;
sigmaH[i] = pow( (float)(Npml-i)/Npml, m )*sigma_max;
sigmaH[i+Npml] = pow( (1.+i)/Npml, m )*sigma_max;
}
for (i=0; i<2*Npml; i++) {
bE[i] = exp( -(sigmaE[i] + alpha)*dt/ep0 );
bH[i] = exp( -(sigmaH[i] + alpha)*dt/ep0 );
aE[i] = sigmaE[i]/(sigmaE[i]+alpha)*(bE[i]-1);
aH[i] = sigmaH[i]/(sigmaH[i]+alpha)*(bH[i]-1);
}
free(sigmaE);
free(sigmaH);
// Allocate host memory for CPML
P3F3 psixE, psiyE, psizE;
P3F3 psixH, psiyH, psizH;
psixE.y = makeArray3D( 2*Npml, N.y, N.z );
psixE.z = makeArray3D( 2*Npml, N.y, N.z );
psiyE.z = makeArray3D( N.x, 2*Npml, N.z );
psiyE.x = makeArray3D( N.x, 2*Npml, N.z );
psizE.x = makeArray3D( N.x, N.y, 2*Npml );
psizE.y = makeArray3D( N.x, N.y, 2*Npml );
psixH.y = makeArray3D( 2*Npml, N.y, N.z );
psixH.z = makeArray3D( 2*Npml, N.y, N.z );
psiyH.z = makeArray3D( N.x, 2*Npml, N.z );
psiyH.x = makeArray3D( N.x, 2*Npml, N.z );
psizH.x = makeArray3D( N.x, N.y, 2*Npml );
psizH.y = makeArray3D( N.x, N.y, 2*Npml );
*/
t0 = time(0);
for ( tstep=1; tstep<=TMAX; tstep++ ) {
updateE( N, E, H, CE );
/*
updateCPMLxE( N, E, H, CE, 1, Npml+1, 1, N.y-1, 1, N.z-1, psixE.y, psixE.z, bE, aE, 0 );
updateCPMLxE( N, E, H, CE, N.x-(Npml+1), N.x-1, 1, N.y-1, 1, N.z-1, psixE.y, psixE.z, bE, aE, 1 );
updateCPMLyE( N, E, H, CE, 1, N.x-1, 1, Npml+1, 1, N.z-1, psiyE.z, psiyE.x, bE, aE, 0 );
updateCPMLyE( N, E, H, CE, 1, N.x-1, N.y-(Npml+1), N.y-1, 1, N.z-1, psiyE.z, psiyE.x, bE, aE, 1 );
updateCPMLzE( N, E, H, CE, 1, N.x-1, 1, N.y-1, 1, Npml+1, psizE.x, psizE.y, bE, aE, 0 );
updateCPMLzE( N, E, H, CE, 1, N.x-1, 1, N.y-1, N.z-(Npml+1), N.z-1, psizE.x, psizE.y, bE, aE, 1 );
*/
updateSrc( N, E, tstep );
updateH( N, E, H );
/*
updateCPMLxH( N, E, H, CE, 1, Npml+1, 1, N.y, 1, N.z, psixH.y, psixH.z, bH, aH, 0 );
updateCPMLxH( N, E, H, CE, N.x-Npml, N.x, 1, N.y, 1, N.z, psixH.y, psixH.z, bH, aH, 1 );
updateCPMLyH( N, E, H, CE, 1, N.x, 1, Npml+1, 1, N.z, psiyH.z, psiyH.x, bH, aH, 0 );
updateCPMLyH( N, E, H, CE, 1, N.x, N.y-Npml, N.y, 1, N.z, psiyH.z, psiyH.x, bH, aH, 1 );
updateCPMLzH( N, E, H, CE, 2, N.x, 1, N.y, 1, Npml+1, psizH.x, psizH.y, bH, aH, 0 );
updateCPMLzH( N, E, H, CE, 1, N.x, 1, N.y, N.z-Npml, N.z, psizH.x, psizH.y, bH, aH, 1 );
*/
/*
if ( tstep/50*50 == tstep ) {
dumpToH5(N.x, N.y, N.z, N.x/2, 0, 0, N.x/2, N.y-1, N.z-1, E.x, "cpu_png/Ex-%05d.h5", tstep);
exec("h5topng -ZM0.1 -x0 -S4 -c /usr/share/h5utils/colormaps/dkbluered cpu_png/Ex-%05d.h5", tstep);
//dumpToH5(N.x, N.y, N.z, 0, 0, N.z/2, N.x-1, N.y-1, N.z/2, E.z, "cpu_png/Ez-%05d.h5", tstep);
//exec("h5topng -ZM0.1 -z0 -S4 -c /usr/share/h5utils/colormaps/dkbluered cpu_png/Ez-%05d.h5", tstep);
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
*/
}
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
