/**
* Begin pdf plotting - initialize a new document
* \param path Output file path
* \param pg_width page width
* \param pg_height page height
*/
bool pdf_begin(struct print_settings *print_settings)
{
pdfw_gs_init();
if (pdf_doc != NULL)
HPDF_Free(pdf_doc);
pdf_doc = HPDF_New(error_handler, NULL);
if (!pdf_doc) {
NSLOG(netsurf, INFO, "Error creating pdf_doc");
return false;
}
settings = print_settings;
page_width = settings->page_width -
FIXTOFLT(FSUB(settings->margins[MARGINLEFT],
settings->margins[MARGINRIGHT]));
page_height = settings->page_height -
FIXTOFLT(settings->margins[MARGINTOP]);
#ifndef PDF_DEBUG
if (option_enable_PDF_compression)
HPDF_SetCompressionMode(pdf_doc, HPDF_COMP_ALL); /*Compression on*/
#endif
HPDF_SetInfoAttr(pdf_doc, HPDF_INFO_CREATOR, user_agent_string());
pdf_page = NULL;
#ifdef PDF_DEBUG
NSLOG(netsurf, INFO, "pdf_begin finishes");
#endif
return true;
}
MRI_IMAGE * mri_double_up( MRI_IMAGE *fim , int xadd,int yadd,int zadd )
{
MRI_IMAGE *gim ;
int nxf,nyf,nzf , nxg,nyg,nzg , nxyf,nxyg , ii,jj,kk , im,jm,km,ip,jp,kp ;
float *far , *gar ;
ENTRY("mri_double_up") ;
if( fim == NULL ) RETURN(NULL) ;
/* process a non-float image? */
if( fim->kind != MRI_float ){
MRI_IMAGE *qim = mri_to_float(fim) ;
gim = mri_double_up(qim,xadd,yadd,zadd) ; mri_free(qim) ; RETURN(gim) ;
}
/* f=input g=output */
nxf = fim->nx ; nyf = fim->ny ; nzf = fim->nz ;
nxg = (nxf == 1) ? 1 : (2*nxf+(xadd != 0)) ;
nyg = (nyf == 1) ? 1 : (2*nyf+(yadd != 0)) ;
nzg = (nzf == 1) ? 1 : (2*nzf+(zadd != 0)) ;
nxyf = nxf*nyf ; nxyg = nxg*nyg ;
gim = mri_new_vol(nxg,nyg,nzg,MRI_float) ;
gar = MRI_FLOAT_PTR(gim) ;
far = MRI_FLOAT_PTR(fim) ;
/* for even output indexes, use the corresponding index in the input;
for odd output indexes, use the neighboring indexes in the input. */
for( kk=0 ; kk < nzg ; kk++ ){
kp = km = kk/2 ; if( kp >= nzf ) kp = km = nzf-1 ;
if( kk%2 ){ kp++; if( kp >= nzf ) kp = nzf-1; }
for( jj=0 ; jj < nyg ; jj++ ){
jp = jm = jj/2 ; if( jp >= nyf ) jp = jm = nyf-1 ;
if( jj%2 ){ jp++; if( jp >= nyf ) jp = nyf-1; }
for( ii=0 ; ii < nxg ; ii++ ){
ip = im = ii/2 ; if( ip >= nxf ) ip = im = nxf-1 ;
if( ii%2 ){ ip++; if( ip >= nxf ) ip = nxf-1; }
FSUB(gar,ii,jj,kk,nxg,nxyg) =
0.125f * ( FSUB(far,im,jm,km,nxf,nxyf) + FSUB(far,ip,jm,km,nxf,nxyf)
+FSUB(far,im,jp,km,nxf,nxyf) + FSUB(far,ip,jp,km,nxf,nxyf)
+FSUB(far,im,jm,kp,nxf,nxyf) + FSUB(far,ip,jm,kp,nxf,nxyf)
+FSUB(far,im,jp,kp,nxf,nxyf) + FSUB(far,ip,jp,kp,nxf,nxyf) ) ;
}}}
RETURN(gim) ;
}
MRI_IMAGE * mri_double_down( MRI_IMAGE *fim )
{
MRI_IMAGE *gim=NULL ;
float *far , *gar , par[7] ;
int nxf,nyf,nzf , nxg,nyg,nzg , nxyf,nxyg , ii,jj,kk ;
int iuu,iup,ium , juu,jum,jup , kuu,kum,kup ;
ENTRY("mri_double_down") ;
if( fim == NULL ) RETURN(NULL) ;
/* process non-float image? */
if( fim->kind != MRI_float ){
MRI_IMAGE *qim = mri_to_float(fim) ;
gim = mri_double_down(qim) ; mri_free(qim) ; RETURN(gim) ;
}
/* f=input g=output */
nxf = fim->nx ; nyf = fim->ny ; nzf = fim->nz ;
nxg = nxf / 2 ; if( nxg < 1 ) nxg = 1 ;
nyg = nyf / 2 ; if( nyg < 1 ) nyg = 1 ;
nzg = nzf / 2 ; if( nzg < 1 ) nzg = 1 ;
nxyf = nxf*nyf ; nxyg = nxg*nyg ;
gim = mri_new_vol(nxg,nyg,nzg,MRI_float) ;
gar = MRI_FLOAT_PTR(gim) ;
far = MRI_FLOAT_PTR(fim) ;
/* for each output voxel (gim), take the median of the
corresponding input voxel and its 6 nearest neighbors */
for( kk=0 ; kk < nzg ; kk++ ){
kuu = 2*kk ; kum = kuu-1 ; if( kum < 0 ) kum = 0 ;
kup = kuu+1 ; if( kup >= nzf ) kup = nzf-1 ;
for( jj=0 ; jj < nyg ; jj++ ){
juu = 2*jj ; jum = juu-1 ; if( jum < 0 ) jum = 0 ;
jup = juu+1 ; if( jup >= nyf ) jup = nyf-1 ;
for( ii=0 ; ii < nxg ; ii++ ){
iuu = 2*ii ; ium = iuu-1 ; if( ium < 0 ) ium = 0 ;
iup = iuu+1 ; if( iup >= nxf ) iup = nxf-1 ;
par[0] = FSUB(far,iuu,juu,kuu,nxf,nxyf) ; /* load par */
par[1] = FSUB(far,ium,juu,kuu,nxf,nxyf) ; /* with the */
par[2] = FSUB(far,iup,juu,kuu,nxf,nxyf) ; /* 7 values */
par[3] = FSUB(far,iuu,jum,kuu,nxf,nxyf) ; /* at and */
par[4] = FSUB(far,iuu,jup,kuu,nxf,nxyf) ; /* around */
par[5] = FSUB(far,iuu,juu,kum,nxf,nxyf) ; /* the voxel */
par[6] = FSUB(far,iuu,juu,kup,nxf,nxyf) ;
FSUB(gar,ii,jj,kk,nxg,nxyg) = median7(par) ;
}}}
RETURN(gim) ;
}
/*===========================================================================
This function format double num to AECHAR, 3 pos hold
===========================================================================*/
AECHAR* TS_FLT2SZ_3(AECHAR* szBuf, double val)
{
#if 1
double tmp = 0, tt = 0, min = 0;
int d = 0, m = 0;
int zero_pad = 0;
char strZero[4];
AECHAR szZero[16];
if (szBuf == NULL)
return NULL;
tmp = FABS(val);
if (FCMP_GE(tmp, 0.001))
{
tt = FFLOOR(tmp);
d = FLTTOINT(tt);
m = FLTTOINT(FMUL(FSUB(tmp, tt), 10000.0));
m = (m % 10 >= 5) ? (m + 10) / 10 : m / 10;
if (m > 0)
{
if (m < 100) //0.012
{
zero_pad++;
}
if (m < 10) //0.001
{
zero_pad++;
}
//补充后面的0
if (zero_pad > 0)
{
STRNCPY(strZero, "000", zero_pad);
strZero[zero_pad] = 0;
STRTOWSTR(strZero, szZero, 16);
}
}
}
else
{
d = 0;
m = 0;
}
if (zero_pad > 0)
WSPRINTF(szBuf, 32, L"%d.%s%d", d, szZero, m);
else
WSPRINTF(szBuf, 32, L"%d.%d", d, m);
return szBuf;
#else
FLOATTOWSTR(val, szBuf, 32);
#endif
}
/**
* The content is resized to fit page width.
*
* \param content The content to be printed
* \param settings The settings for printing to use
* \return true if successful, false otherwise
*/
bool print_apply_settings(hlcache_handle *content,
struct print_settings *settings)
{
if (settings == NULL)
return false;
/* Apply settings - adjust page size etc */
page_content_width = (settings->page_width -
FIXTOFLT(FSUB(settings->margins[MARGINLEFT],
settings->margins[MARGINRIGHT]))) / settings->scale;
page_content_height = (settings->page_height -
FIXTOFLT(FSUB(settings->margins[MARGINTOP],
settings->margins[MARGINBOTTOM]))) / settings->scale;
content_reformat(content, false, page_content_width, 0);
LOG("New layout applied.New height = %d ; New width = %d ", content_get_height(content), content_get_width(content));
return true;
}
/**
* Convert Hue Saturation Lightness value to RGB.
*
* \param hue Hue in degrees 0..360
* \param sat Saturation value in percent 0..100
* \param lit Lightness value in percent 0..100
* \param r red component
* \param g green component
* \param b blue component
*/
static void HSL_to_RGB(css_fixed hue, css_fixed sat, css_fixed lit, uint8_t *r, uint8_t *g, uint8_t *b)
{
css_fixed min_rgb, max_rgb, chroma;
css_fixed relative_hue, scaled_hue, mid1, mid2;
int sextant;
#define ORGB(R, G, B) \
*r = FIXTOINT(FDIV(FMUL((R), F_255), F_100)); \
*g = FIXTOINT(FDIV(FMUL((G), F_255), F_100)); \
*b = FIXTOINT(FDIV(FMUL((B), F_255), F_100))
/* If saturation is zero there is no hue and r = g = b = lit */
if (sat == INTTOFIX(0)) {
ORGB(lit, lit, lit);
return;
}
/* Compute max(r,g,b) */
if (lit <= INTTOFIX(50)) {
max_rgb = FDIV(FMUL(lit, FADD(sat, F_100)), F_100);
} else {
max_rgb = FDIV(FSUB(FMUL(FADD(lit, sat), F_100), FMUL(lit, sat)), F_100);
}
/* Compute min(r,g,b) */
min_rgb = FSUB(FMUL(lit, INTTOFIX(2)), max_rgb);
/* We know that the value of at least one of the components is
* max(r,g,b) and that the value of at least one of the other
* components is min(r,g,b).
*
* We can determine which components have these values by
* considering which the sextant of the hexcone the hue lies
* in:
*
* Sextant: max(r,g,b): min(r,g,b):
*
* 0 r b
* 1 g b
* 2 g r
* 3 b r
* 4 b g
* 5 r g
*
* Thus, we need only compute the value of the third component
*/
/* Chroma is the difference between min and max */
chroma = FSUB(max_rgb, min_rgb);
/* Compute which sextant the hue lies in (truncates result) */
hue = FDIV(FMUL(hue, INTTOFIX(6)), F_360);
sextant = FIXTOINT(hue);
/* Compute offset of hue from start of sextant */
relative_hue = FSUB(hue, INTTOFIX(sextant));
/* Scale offset by chroma */
scaled_hue = FMUL(relative_hue, chroma);
/* Compute potential values of the third colour component */
mid1 = FADD(min_rgb, scaled_hue);
mid2 = FSUB(max_rgb, scaled_hue);
/* Populate result */
switch (sextant) {
case 0: ORGB(max_rgb, mid1, min_rgb); break;
case 1: ORGB(mid2, max_rgb, min_rgb); break;
case 2: ORGB(min_rgb, max_rgb, mid1); break;
case 3: ORGB(min_rgb, mid2, max_rgb); break;
case 4: ORGB(mid1, min_rgb, max_rgb); break;
case 5: ORGB(max_rgb, min_rgb, mid2); break;
}
#undef ORGB
}
MRI_IMAGE * mri_local_percmean( MRI_IMAGE *fim , float vrad , float p1, float p2 )
{
MRI_IMAGE *aim , *bim , *cim , *dim ;
float *aar , *bar , *car , *dar ;
byte *ams , *bms ;
MCW_cluster *nbhd ;
int ii , nx,ny,nz,nxy,nxyz ;
float vbot=0.0f ;
ENTRY("mri_local_percmean") ;
if( p1 > p2 ){ float val = p1; p1 = p2; p2 = val; }
if( fim == NULL || vrad < 4.0f || p1 < 0.0f || p2 > 100.0f ) RETURN(NULL) ;
/* just one percentile? */
if( p1 == p2 ) RETURN( mri_local_percentile(fim,vrad,p1) ) ;
if( verb ) fprintf(stderr,"A") ;
/* create automask of copy of input image */
aim = mri_to_float(fim) ; aar = MRI_FLOAT_PTR(aim) ;
ams = mri_automask_image(aim) ;
if( ams == NULL ){ mri_free(aim) ; RETURN(NULL) ; }
/* apply automask to copy of input image */
for( ii=0 ; ii < aim->nvox ; ii++ ) if( ams[ii] == 0 ) aar[ii] = 0.0f ;
free(ams) ;
/* shrink image by 2 for speed */
if( verb ) fprintf(stderr,"D") ;
bim = mri_double_down(aim) ; bar = MRI_FLOAT_PTR(bim) ; mri_free(aim) ;
bms = (byte *)malloc(sizeof(byte)*bim->nvox) ;
for( ii=0 ; ii < bim->nvox ; ii++ ) bms[ii] = (bar[ii] != 0.0f) ;
if( !USE_ALL_VALS ){
vbot = 0.00666f * mri_max(bim) ;
}
/* create neighborhood mask (1/2 radius in the shrunken copy) */
nbhd = MCW_spheremask( 1.0f,1.0f,1.0f , 0.5f*vrad+0.001f ) ;
cim = mri_new_conforming(bim,MRI_float) ; car = MRI_FLOAT_PTR(cim) ;
SetSearchAboutMaskedVoxel(1) ;
nx = bim->nx ; ny = bim->ny ; nz = bim->nz ; nxy = nx*ny ; nxyz = nxy*nz ;
/* for each output voxel,
extract neighborhood array, sort it, average desired range.
Since this is the slowest part of the code, it is now OpenMP-ized. */
#ifndef USE_OMP /* old serial code */
{ int vvv,vstep , ii,jj,kk , nbar_num ; float val , *nbar ;
nbar = (float *)malloc(sizeof(float)*nbhd->num_pt) ;
vstep = (verb) ? nxyz/50 : 0 ;
if( vstep ) fprintf(stderr,"\n + Voxel loop: ") ;
for( vvv=kk=0 ; kk < nz ; kk++ ){
for( jj=0 ; jj < ny ; jj++ ){
for( ii=0 ; ii < nx ; ii++,vvv++ ){
if( vstep && vvv%vstep == vstep-1 ) vstep_print() ;
nbar_num = mri_get_nbhd_array( bim,bms , ii,jj,kk , nbhd,nbar ) ;
if( nbar_num < 1 ){ /* no data */
val = 0.0f ;
} else {
qsort_float(nbar_num,nbar) ; /* sort */
if( nbar_num == 1 ){ /* stoopid case */
val = nbar[0] ;
} else { /* average values from p1 to p2 percentiles */
int q1,q2,qq , qb;
if( !USE_ALL_VALS ){ /* Ignore tiny values [17 May 2016] */
for( qb=0 ; qb < nbar_num && nbar[qb] <= vbot ; qb++ ) ; /*nada*/
if( qb == nbar_num ){
val = 0.0f ;
} else if( qb == nbar_num-1 ){
val = nbar[qb] ;
} else {
q1 = (int)( 0.01f*p1*(nbar_num-1-qb)) + qb; if( q1 > nbar_num-1 ) q1 = nbar_num-1;
q2 = (int)( 0.01f*p2*(nbar_num-1-qb)) + qb; if( q2 > nbar_num-1 ) q2 = nbar_num-1;
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
} else { /* Use all values [the olden way] */
q1 = (int)( 0.01f*p1*(nbar_num-1) ) ; /* p1 location */
q2 = (int)( 0.01f*p2*(nbar_num-1) ) ; /* p2 location */
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
}
}
FSUB(car,ii,jj,kk,nx,nxy) = val ;
}}}
free(nbar) ;
if( vstep ) fprintf(stderr,"!") ;
}
#else /* new parallel code [06 Mar 2013 = Snowquestration Day!] */
AFNI_OMP_START ;
if( verb ) fprintf(stderr,"V") ;
#pragma omp parallel
{ int vvv , ii,jj,kk,qq , nbar_num ; float val , *nbar ;
nbar = (float *)malloc(sizeof(float)*nbhd->num_pt) ;
#pragma omp for
for( vvv=0 ; vvv < nxyz ; vvv++ ){
ii = vvv % nx ; kk = vvv / nxy ; jj = (vvv-kk*nxy) / nx ;
nbar_num = mri_get_nbhd_array( bim,bms , ii,jj,kk , nbhd,nbar ) ;
if( nbar_num < 1 ){ /* no data */
val = 0.0f ;
} else {
qsort_float(nbar_num,nbar) ; /* sort */
if( nbar_num == 1 ){ /* stoopid case */
val = nbar[0] ;
} else { /* average values from p1 to p2 percentiles */
int q1,q2,qq , qb;
if( !USE_ALL_VALS ){ /* Ignore tiny values [17 May 2016] */
for( qb=0 ; qb < nbar_num && nbar[qb] <= vbot ; qb++ ) ; /*nada*/
if( qb == nbar_num ){
val = 0.0f ;
} else if( qb == nbar_num-1 ){
val = nbar[qb] ;
} else {
q1 = (int)( 0.01f*p1*(nbar_num-1-qb)) + qb; if( q1 > nbar_num-1 ) q1 = nbar_num-1;
q2 = (int)( 0.01f*p2*(nbar_num-1-qb)) + qb; if( q2 > nbar_num-1 ) q2 = nbar_num-1;
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
} else { /* Use all values [the olden way] */
q1 = (int)( 0.01f*p1*(nbar_num-1) ) ; /* p1 location */
q2 = (int)( 0.01f*p2*(nbar_num-1) ) ; /* p2 location */
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
if( verb && vvv%66666==0 ) fprintf(stderr,".") ;
}
}
car[vvv] = val ;
}
free(nbar) ;
} /* end parallel code */
AFNI_OMP_END ;
#endif
mri_free(bim) ; free(bms) ; KILL_CLUSTER(nbhd) ;
/* expand output image back to original size */
dim = mri_double_up( cim , fim->nx%2 , fim->ny%2 , fim->nz%2 ) ;
if( verb ) fprintf(stderr,"U") ;
mri_free(cim) ;
RETURN(dim) ;
}
MRI_IMAGE * mri_local_percentile( MRI_IMAGE *fim , float vrad , float perc )
{
MRI_IMAGE *aim , *bim , *cim , *dim ;
float *aar , *bar , *car , *dar , *nbar ;
byte *ams , *bms ;
MCW_cluster *nbhd ;
int ii,jj,kk , nbar_num , nx,ny,nz,nxy ;
float fq,val ; int qq,qp,qm ;
ENTRY("mri_local_percentile") ;
if( fim == NULL || vrad < 4.0f || perc < 0.0f || perc > 100.0f ) RETURN(NULL) ;
/* compute automask */
aim = mri_to_float(fim) ; aar = MRI_FLOAT_PTR(aim) ;
ams = mri_automask_image(aim) ;
if( ams == NULL ){ mri_free(aim) ; RETURN(NULL) ; }
/* apply automask to image copy */
for( ii=0 ; ii < aim->nvox ; ii++ ) if( ams[ii] == 0 ) aar[ii] = 0.0f ;
free(ams) ;
/* shrink image by 2 for speedup */
bim = mri_double_down(aim) ; bar = MRI_FLOAT_PTR(bim) ; mri_free(aim) ;
bms = (byte *)malloc(sizeof(byte)*bim->nvox) ;
for( ii=0 ; ii < bim->nvox ; ii++ ) bms[ii] = (bar[ii] != 0.0f) ;
/* neighborhood has 1/2 radius in the shrunken volume */
nbhd = MCW_spheremask( 1.0f,1.0f,1.0f , 0.5f*vrad+0.001f ) ;
nbar = (float *)malloc(sizeof(float)*nbhd->num_pt) ;
cim = mri_new_conforming(bim,MRI_float) ; car = MRI_FLOAT_PTR(cim) ;
SetSearchAboutMaskedVoxel(1) ;
nx = bim->nx ; ny = bim->ny ; nz = bim->nz ; nxy = nx*ny ;
/* for each voxel:
extract neighborhood array, sort it, get result */
for( kk=0 ; kk < nz ; kk++ ){
for( jj=0 ; jj < ny ; jj++ ){
for( ii=0 ; ii < nx ; ii++ ){
nbar_num = mri_get_nbhd_array( bim,bms , ii,jj,kk , nbhd,nbar ) ;
if( nbar_num < 1 ){
val = 0.0f ;
} else {
qsort_float(nbar_num,nbar) ;
if( nbar_num == 1 || perc <= 0.000001f ){
val = nbar[0] ;
} else if( perc >= 99.9999f ){
val = nbar[nbar_num-1] ;
} else {
fq = (0.01f*perc)*nbar_num ;
qq = (int)fq ; qp = qq+1 ; if( qp == nbar_num ) qp = qq ;
qm = qq-1 ; if( qm < 0 ) qm = 0 ;
val = 0.3333333f * ( nbar[qm] + nbar[qq] + nbar[qp] ) ;
}
}
FSUB(car,ii,jj,kk,nx,nxy) = val ;
}}}
mri_free(bim) ; free(bms) ; free(nbar) ; KILL_CLUSTER(nbhd) ;
dim = mri_double_up( cim , fim->nx%2 , fim->ny%2 , fim->nz%2 ) ;
mri_free(cim) ;
RETURN(dim) ;
}
