void BM_print(pbit_mat bm)
{
_ASSERT_VALID_BM(bm);
int r, c;
for (r= 0; r<bm->nrow; ++r) {
for (c= 0; c<bm->ncol; ++c) {
printf("%c", BM_get(bm, r, c)?'1':'0');
}
printf("\n");
}
}
void BM_print_with_row_names(pbit_mat bm, print_row_names frow)
{
_ASSERT_VALID_BM(bm);
int r, c;
for (r= 0; r<bm->nrow; ++r) {
frow(r);
for (c= 0; c<bm->ncol; ++c) {
printf("%c", BM_get(bm, r, c)?'1':' ');
}
printf("\n");
}
}
void BM_sort_row(pbit_mat bm)
{
_ASSERT_VALID_BM(bm);
BM_clear_perm_row(bm);
int* newperm= NPALLOC(int, bm->nrow);
int col;
int* vn0= NPALLOC(int, bm->nrow);
int* vn1= NPALLOC(int, bm->nrow);
int i, j;
memset(vn0, 0, bm->ncol*sizeof(int));
memset(vn1, 0, bm->ncol*sizeof(int));
for (i= 0; i<bm->nrow; ++i) {
for (col= 0; col<bm->ncol; col+= _LBTYPE) {
_BTYPE block= BM_get_block(bm, i, col);
for (j= col; j<bm->ncol; ++j, block= block>>1) {
if ((block & 1L)!=0)
++vn1[j];
else
++vn0[j];
}
}
}
int n0, n1;
for (col= bm->ncol-1; col>=0; --col) {
n0= vn0[col];
n1= n0+vn1[col];
for (i= bm->nrow-1; i>=0; --i) {
if (BM_get(bm, i, col)) {
--n1;
newperm[n1]= bm->perm_row[i];
} else {
--n0;
newperm[n0]= bm->perm_row[i];
}
}
int * tmp_perm= bm->perm_row;
bm->perm_row= newperm;
newperm= tmp_perm;
}
pfree(vn0);
pfree(vn1);
pfree(newperm);
}
/*!
\brief Get map attributes
\param buff
\param offset
\param[out] att
\return 0 on failure
\return 1 on success
*/
int get_mapatt(typbuff * buff, int offset, float *att)
{
if (buff->nm) {
if (BM_get
(buff->nm, (offset % buff->nm->cols),
(offset / buff->nm->cols))) {
return (0);
}
}
*att = (buff->ib ? (float)buff->ib[offset] :
buff->sb ? (float)buff->sb[offset] :
buff->cb ? (float)buff->cb[offset] :
buff->fb ? (float)buff->fb[offset] : buff->k);
if (buff->tfunc) {
*att = (buff->tfunc) (*att, offset);
}
return (1);
}
/*!
\brief
Should only be called when setting up the current mask (gs_bm.c)
\param tb pointer to typbuff
\param col number of cols
\param row number of rows
\param offset offset value
\return 1
\return 0
*/
int gs_masked(typbuff * tb, int col, int row, int offset)
{
int ret;
ret = 1;
if (tb->bm) {
ret = BM_get(tb->bm, col, row);
}
else if (tb->cb) {
ret = tb->cb[offset];
}
else if (tb->sb) {
ret = tb->sb[offset];
}
else if (tb->ib) {
ret = tb->ib[offset];
}
else if (tb->fb) {
ret = tb->fb[offset];
}
return (Invertmask ? ret : !ret);
}
int
COGRR1(double x_or, double y_or, double z_or, int n_rows, int n_cols,
int n_levs, int n_points, struct quadruple *points,
struct point_3d skip_point)
/*C
C INTERPOLATION BY FUNCTIONAL METHOD : TPS + complete regul.
c
*/
{
int secpar_loop();
static double *w2 = NULL;
static double *wz2 = NULL;
static double *wz1 = NULL;
double amaxa;
double stepix, stepiy, stepiz, RO, xx, yy, zz, xg, yg, zg, xx2;
double wm, dx, dy, dz, dxx, dyy, dxy, dxz, dyz, dzz, h, bmgd1,
bmgd2, etar, zcon, r, ww, wz, r2, hcell, zzcell2,
etarcell, rcell, wwcell, zzcell;
double x_crs,x_crsd,x_crsdd,x_crsdr2;
int n1, k1, k2, k, i1, l, l1, n4, n5, m, i;
int NGST, LSIZE, ngstc, nszc, ngstr, nszr, ngstl, nszl;
int POINT();
int ind, ind1;
static int first_time_z = 1;
off_t offset, offset1, offset2;
int bmask = 1;
static FCELL *cell = NULL;
int cond1 = (gradient != NULL) || (aspect1 != NULL) || (aspect2 != NULL);
int cond2 = (ncurv != NULL) || (gcurv != NULL) || (mcurv != NULL);
#define CEULER .57721566
/*
C
c character*32 fncdsm
c normalization
c
*/
offset1 = nsizr * nsizc;
stepix = ew_res / dnorm;
stepiy = ns_res / dnorm;
stepiz = tb_res / dnorm;
if (!w2) {
if (!(w2 = (double *)G_malloc(sizeof(double) * (KMAX2 + 1)))) {
clean();
G_fatal_error(_("Not enough memory for %s"), "w2");
}
}
if (!wz2) {
if (!(wz2 = (double *)G_malloc(sizeof(double) * (KMAX2 + 1)))) {
clean();
G_fatal_error(_("Not enough memory for %s"), "wz2");
}
}
if (!wz1) {
if (!(wz1 = (double *)G_malloc(sizeof(double) * (KMAX2 + 1)))) {
clean();
G_fatal_error(_("Not enough memory for %s"), "wz1");
}
}
if (cell == NULL)
cell = Rast_allocate_f_buf();
for (i = 1; i <= n_points; i++) {
points[i - 1].x = (points[i - 1].x - x_or) / dnorm;
points[i - 1].y = (points[i - 1].y - y_or) / dnorm;
points[i - 1].z = (points[i - 1].z - z_or) / dnorm;
}
if (cv) {
skip_point.x = (skip_point.x - x_or) / dnorm;
skip_point.y = (skip_point.y - y_or) / dnorm;
skip_point.z = (skip_point.z - z_or) / dnorm;
}
n1 = n_points + 1;
/*
C
C GENERATION OF MATRIX
C
C FIRST COLUMN
C
*/
A[1] = 0.;
for (k = 1; k <= n_points; k++) {
i1 = k + 1;
A[i1] = 1.;
}
/*
C
C OTHER COLUMNS
C
*/
RO = rsm;
for (k = 1; k <= n_points; k++) {
k1 = k * n1 + 1;
k2 = k + 1;
i1 = k1 + k;
if (rsm < 0.) { /*indicates variable smoothing */
A[i1] = points[k - 1].sm;
}
else {
A[i1] = RO; /* constant smoothing */
}
for (l = k2; l <= n_points; l++) {
xx = points[k - 1].x - points[l - 1].x;
yy = points[k - 1].y - points[l - 1].y;
zz = points[k - 1].z - points[l - 1].z;
r = sqrt(xx * xx + yy * yy + zz * zz);
etar = (fi * r) / 2.;
if (etar == 0.) {
/* printf ("ident. points in segm. \n");
printf ("x[%d]=%lf,x[%d]=%lf,y[%d]=%lf,y[%d]=%lf\n",
k - 1, points[k - 1].x, l - 1, points[l - 1].x, k - 1, points[k - 1].y, l - 1, points[l - 1].y); */
}
i1 = k1 + l;
A[i1] = crs(etar);
}
}
/*
C
C SYMMETRISATION
C
*/
amaxa = 1.;
for (k = 1; k <= n1; k++) {
k1 = (k - 1) * n1;
k2 = k + 1;
for (l = k2; l <= n1; l++) {
m = (l - 1) * n1 + k;
A[m] = A[k1 + l];
amaxa = amax1(A[m], amaxa);
}
}
/*
C RIGHT SIDE
C
*/
n4 = n1 * n1 + 1;
A[n4] = 0.;
for (l = 1; l <= n_points; l++) {
l1 = n4 + l;
A[l1] = points[l - 1].w;
}
n5 = n1 * (n1 + 1);
for (i = 1; i <= n5; i++)
A[i] = A[i] / amaxa;
/*
SOLVING OF SYSTEM
*/
if (LINEQS(n1, n1, 1, &NERROR, &DETERM)) {
for (k = 1; k <= n_points; k++) {
l = n4 + k;
b[k] = A[l];
}
b[n_points + 1] = A[n4];
POINT(n_points, points, skip_point);
if (cv)
return 1;
if (devi != NULL && sig1 == 1)
return 1;
/*
C
C INTERPOLATION * MOST INNER LOOPS !
C
*/
NGST = 1;
LSIZE = 0;
ngstc = (int)(x_or / ew_res + 0.5) + 1;
nszc = ngstc + n_cols - 1;
ngstr = (int)(y_or / ns_res + 0.5) + 1;
nszr = ngstr + n_rows - 1;
ngstl = (int)(z_or / tb_res + 0.5) + 1;
nszl = ngstl + n_levs - 1;
/* fprintf(stderr," Progress percentage for each segment ..." ); */
/*fprintf(stderr,"Before loops,ngstl = %d,nszl =%d\n",ngstl,nszl); */
for (i = ngstl; i <= nszl; i++) {
/*fprintf(stderr,"level=%d\n",i); */
/* G_percent(i, nszl, 2); */
offset = offset1 * (i - 1); /* levels offset */
zg = (i - ngstl) * stepiz;
for (m = 1; m <= n_points; m++) {
wz = zg - points[m - 1].z;
wz1[m] = wz;
wz2[m] = wz * wz;
}
for (k = ngstr; k <= nszr; k++) {
yg = (k - ngstr) * stepiy;
for (m = 1; m <= n_points; m++) {
wm = yg - points[m - 1].y;
w[m] = wm;
w2[m] = wm * wm;
}
if ((cellinp != NULL) && (cellout != NULL) && (i == ngstl))
Rast_get_f_row(fdcell, cell, n_rows_in - k);
for (l = ngstc; l <= nszc; l++) {
LSIZE = LSIZE + 1;
if (maskmap != NULL)
bmask = BM_get(bitmask, l - 1, k - 1); /*bug fix 02/03/00 jh */
xg = (l - ngstc) * stepix;
ww = 0.;
wwcell = 0.;
dx = 0.;
dy = 0.;
dz = 0.;
dxx = 0.;
dxy = 0.;
dxz = 0.;
dyy = 0.;
dyz = 0.;
dzz = 0.;
/* compute everything for area which is not masked out
and where cross_input map doesn't have nulls */
if (bmask == 1 && !(cell && Rast_is_f_null_value(&cell[l - 1]))) {
h = b[n1];
hcell = b[n1];
for (m = 1; m <= n_points; m++) {
xx = xg - points[m - 1].x;
xx2 = xx * xx;
if ((cellinp != NULL) && (cellout != NULL) &&
(i == ngstl)) {
zcon = (double)(cell[l - 1] * zmult - z_or) - z_orig_in * zmult; /* bug fix 02/03/00 jh */
zcon = zcon / dnorm;
zzcell = zcon - points[m - 1].z;
zzcell2 = zzcell * zzcell;
rcell = sqrt(xx2 + w2[m] + zzcell2);
etarcell = (fi * rcell) / 2.;
hcell = hcell + b[m] * crs(etarcell);
}
r2 = xx2 + w2[m] + wz2[m];
r = sqrt(r2);
etar = (fi * r) / 2.;
crs_full(
etar,fi,
&x_crs,
cond1?&x_crsd:NULL,
cond2?&x_crsdr2:NULL,
cond2?&x_crsdd:NULL
);
h = h + b[m] * x_crs;
if(cond1)
{
bmgd1 = b[m] * x_crsd;
dx = dx + bmgd1 * xx;
dy = dy + bmgd1 * w[m];
dz = dz + bmgd1 * wz1[m];
}
if(cond2)
{
bmgd2 = b[m] * x_crsdd;
bmgd1 = b[m] * x_crsdr2;
dyy = dyy + bmgd2 * w2[m] + bmgd1 * w2[m];
dzz = dzz + bmgd2 * wz2[m] + bmgd1 * wz2[m];
dxy = dxy + bmgd2 * xx * w[m] + bmgd1 * xx * w[m];
dxz = dxz + bmgd2 * xx * wz1[m] + bmgd1 * xx * wz1[m];
dyz = dyz + bmgd2 * w[m] * wz1[m] + bmgd1 * w[m] * wz1[m];
}
}
ww = h + wmin;
if ((cellinp != NULL) && (cellout != NULL) &&
(i == ngstl))
wwcell = hcell + wmin;
az[l] = ww;
if (first_time_z) {
first_time_z = 0;
zmaxac = zminac = ww;
if ((cellinp != NULL) && (cellout != NULL) &&
(i == ngstl))
zmaxacell = zminacell = wwcell;
}
zmaxac = amax1(ww, zmaxac);
zminac = amin1(ww, zminac);
if ((cellinp != NULL) && (cellout != NULL) &&
(i == ngstl)) {
zmaxacell = amax1(wwcell, zmaxacell);
zminacell = amin1(wwcell, zminacell);
}
if ((ww > wmax + 0.1 * (wmax - wmin))
|| (ww < wmin - 0.1 * (wmax - wmin))) {
static int once = 0;
if (!once) {
once = 1;
fprintf(stderr, "WARNING:\n");
fprintf(stderr,
"Overshoot -- increase in tension suggested.\n");
fprintf(stderr,
"Overshoot occurs at (%d,%d,%d) cell\n",
l, k, i);
fprintf(stderr,
"The w-value is %lf, wmin is %lf,wmax is %lf\n",
ww, wmin, wmax);
}
}
} /* skip here if you are in masked area, ww should be 0 */
az[l] = ww;
adx[l] = dx;
ady[l] = dy;
adz[l] = dz;
/* printf("\n %f", ww); */
adxx[l] = dxx;
adxy[l] = dxy;
adxz[l] = dxz;
adyy[l] = dyy;
adyz[l] = dyz;
adzz[l] = dzz;
if ((gradient != NULL) || (aspect1 != NULL) ||
(aspect2 != NULL)
|| (ncurv != NULL) || (gcurv != NULL) ||
(mcurv != NULL))
if (!(secpar_loop(ngstc, nszc, l))) {
clean();
G_fatal_error(_("Secpar_loop failed"));
}
if ((cellinp != NULL) && (cellout != NULL) &&
(i == ngstl)) {
zero_array_cell[l - 1] = (FCELL) (wwcell);
}
if (outz != NULL) {
zero_array1[l - 1] = (float)(az[l] * sciz);
}
if (gradient != NULL) {
zero_array2[l - 1] = (float)(adx[l]);
}
if (aspect1 != NULL) {
zero_array3[l - 1] = (float)(ady[l]);
}
if (aspect2 != NULL) {
zero_array4[l - 1] = (float)(adz[l]);
}
if (ncurv != NULL) {
zero_array5[l - 1] = (float)(adxx[l]);
}
if (gcurv != NULL) {
zero_array6[l - 1] = (float)(adyy[l]);
}
if (mcurv != NULL) {
zero_array7[l - 1] = (float)(adxy[l]);
}
} /* columns */
ind = nsizc * (k - 1) + (ngstc - 1);
ind1 = ngstc - 1;
offset2 = offset + ind; /* rows*cols offset */
if ((cellinp != NULL) && (cellout != NULL) && (i == ngstl)) {
G_fseek(Tmp_fd_cell, ((off_t)ind * sizeof(FCELL)), 0);
if (!
(fwrite
(zero_array_cell + ind1, sizeof(FCELL),
nszc - ngstc + 1, Tmp_fd_cell))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (outz != NULL) {
G_fseek(Tmp_fd_z, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array1 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_z))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (gradient != NULL) {
G_fseek(Tmp_fd_dx, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array2 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_dx))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (aspect1 != NULL) {
G_fseek(Tmp_fd_dy, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array3 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_dy))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (aspect2 != NULL) {
G_fseek(Tmp_fd_dz, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array4 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_dz))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (ncurv != NULL) {
G_fseek(Tmp_fd_xx, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array5 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_xx))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (gcurv != NULL) {
G_fseek(Tmp_fd_yy, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array6 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_yy))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
if (mcurv != NULL) {
G_fseek(Tmp_fd_xy, (off_t)(offset2 * sizeof(float)), 0);
if (!
(fwrite
(zero_array7 + ind1, sizeof(float), nszc - ngstc + 1,
Tmp_fd_xy))) {
clean();
G_fatal_error
(_("Not enough disk space--cannot write files"));
}
}
}
}
} /* falls here if LINEQS() returns 0 */
/* total++; */
/*fprintf(stderr,"wminac=%lf,wmaxac=%lf\n",zminac,zmaxac); */
return 1;
}
/*!
\brief Check if point is masked
\param gs pointer to geosurf struct
\param pt point coordinates (X,Y,Z)
\return 1 masked
\return 0 not masked
*/
int gs_point_is_masked(geosurf * gs, float *pt)
{
int vrow, vcol, drow, dcol;
int retmask = 0, npts = 0;
float p2[2];
if (!gs->curmask) {
return (0);
}
vrow = Y2VROW(gs, pt[Y]);
vcol = X2VCOL(gs, pt[X]);
/* check right & bottom edges */
if (pt[X] == VCOL2X(gs, VCOLS(gs))) {
/* right edge */
vcol -= 1;
}
if (pt[Y] == VROW2Y(gs, VROWS(gs))) {
/* bottom edge */
vrow -= 1;
}
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_TL;
npts++;
}
dcol = VCOL2DCOL(gs, vcol + 1);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_TR;
npts++;
}
drow = VROW2DROW(gs, vrow + 1);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_BR;
npts++;
}
dcol = VCOL2DCOL(gs, vcol);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_BL;
npts++;
}
if (npts != 1) {
/* zero or masked */
return (retmask | npts);
}
p2[X] = VCOL2X(gs, vcol);
p2[Y] = VROW2Y(gs, vrow + 1);
switch (retmask) {
case MASK_TL:
if ((pt[X] - p2[X]) / VXRES(gs) > (pt[Y] - p2[Y]) / VYRES(gs)) {
/* lower triangle */
return (0);
}
return (retmask | npts);
case MASK_TR:
return (retmask | npts);
case MASK_BR:
if ((pt[X] - p2[X]) / VXRES(gs) <= (pt[Y] - p2[Y]) / VYRES(gs)) {
/* upper triangle */
return (0);
}
return (retmask | npts);
case MASK_BL:
return (retmask | npts);
}
/* Assume that if we get here it is an error */
return (0);
}
int OUTGR()
{
void *cf1, *cf2, *cf3, *cf4, *cf5, *cf6, *cf7;
int read_val;
FCELL *cell;
float *data;
int i, iarc, cnt;
int bmask = 1;
int x, y;
float value;
if ((cellinp != NULL) && (cellout != NULL)) {
cell = Rast_allocate_f_buf();
for (i = 0; i < nsizr; i++) {
/* seek to the right row */
G_fseek
(Tmp_fd_cell, ((off_t)(nsizr - 1 - i) * nsizc * sizeof(FCELL)),
0);
fread(cell, sizeof(FCELL), nsizc, Tmp_fd_cell);
Rast_put_f_row(fdcout, cell);
}
}
/*** Initialize output g3d region ***/
current_region.bottom = z_orig_in;
current_region.top = nsizl * tb_res_in + z_orig_in;
if (!(data = (float *)G_malloc(sizeof(float) * nsizr * nsizc * nsizl))) {
clean();
G_fatal_error(_("Out of memory"));
}
/*** Write elevation results ***/
if (outz != NULL) {
cf1 = Rast3d_open_new_opt_tile_size(outz, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf1 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), outz);
}
/* seek to the beginning */
G_fseek(Tmp_fd_z, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_z);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt];
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf1, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf1) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), outz);
} else
G_message(_("3D raster map <%s> created"), outz);
}
/*** Write out the gradient results ***/
if (gradient != NULL) {
cf2 = Rast3d_open_new_opt_tile_size(gradient, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf2 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), gradient);
}
/* seek to the beginning */
G_fseek(Tmp_fd_dx, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_dx);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt];
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf2, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf2) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), gradient);
} else
G_message(_("3D raster map <%s> created"), gradient);
}
/*** Write out aspect1 results ***/
if (aspect1 != NULL) {
cf3 = Rast3d_open_new_opt_tile_size(aspect1, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf3 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), aspect1);
}
/* seek to the beginning */
G_fseek(Tmp_fd_dy, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_dy);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt] * 180 / M_PI;
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf3, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf3) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), aspect1);
} else
G_message(_("3D raster map <%s> created"), aspect1);
}
/*** Write out aspect2 results ***/
if (aspect2 != NULL) {
cf4 = Rast3d_open_new_opt_tile_size(aspect2, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf4 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), aspect2);
}
/* seek to the beginning */
G_fseek(Tmp_fd_dz, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_dz);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt] * 180 / M_PI;
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf4, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf4) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), aspect2);
} else
G_message(_("3D raster map <%s> created"), aspect2);
}
/*** Write out ncurv results ***/
if (ncurv != NULL) {
cf5 = Rast3d_open_new_opt_tile_size(ncurv, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf5 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), ncurv);
}
/* seek to the beginning */
G_fseek(Tmp_fd_xx, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_xx);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt];
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf5, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf5) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), ncurv);
} else
G_message(_("3D raster map <%s> created"), ncurv);
}
/*** Write out gcurv results ***/
if (gcurv != NULL) {
cf6 = Rast3d_open_new_opt_tile_size(gcurv, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf6 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), gcurv);
}
/* seek to the beginning */
G_fseek(Tmp_fd_yy, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_yy);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt];
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf6, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf6) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), gcurv);
} else
G_message(_("3D raster map <%s> created"), gcurv);
}
/*** Write mcurv results ***/
if (mcurv != NULL) {
cf7 = Rast3d_open_new_opt_tile_size(mcurv, RASTER3D_USE_CACHE_DEFAULT, ¤t_region, FCELL_TYPE, 32);
if (cf7 == NULL) {
clean();
G_fatal_error(_("Unable to open %s for writing"), mcurv);
}
/* seek to the beginning */
G_fseek(Tmp_fd_xy, 0L, 0);
/* Read data in from temp file */
read_val =
fread(data, sizeof(float), nsizr * nsizc * nsizl, Tmp_fd_xy);
if (read_val < 0) {
clean();
G_fatal_error(_("Unable to read data from temp file"));
}
cnt = 0;
for (iarc = 0; iarc < nsizl; iarc++) {
for (y = nsizr - 1; y >= 0; y--) { /* changed by AV */
for (x = 0; x < nsizc; x++) {
if (maskmap != NULL)
bmask = BM_get(bitmask, x, nsizr - y - 1);
else
bmask = 1;
value = data[cnt];
if (!bmask)
Rast3d_set_null_value(&value, 1, FCELL_TYPE);
if (Rast3d_put_float(cf7, x, y, iarc, value) == 0) {
clean();
G_fatal_error(
_("Error writing cell (%d,%d,%d) with value %f"),
x, y, iarc, value);
}
cnt++;
}
}
}
/* Close the file */
if (Rast3d_close(cf7) == 0) {
clean();
G_fatal_error(_("Error closing output file %s"), mcurv);
} else
G_message(_("3D raster map <%s> created"), mcurv);
}
G_free(data);
return 1;
}
/*!
\brief Calculate normals
Need either four neighbors or two non-linear neighbors
passed initial state of neighbors known from array position
and data row & col
\param gs surface (geosurf)
\param drow data row
\param dcol data col
\param neighbors neighbors id
\return 0 no normals
\return 1 on success
*/
int calc_norm(geosurf * gs, int drow, int dcol, unsigned int neighbors)
{
long noffset;
float temp[3], normalizer, dz1, dz2, z0, z1, z2, z3, z4;
if (gs->curmask) {
/* need to check masked neighbors */
/* NOTE: this should automatically eliminate nullvals */
if (neighbors & NTOP) {
if (BM_get(gs->curmask, dcol, drow - gs->y_mod)) {
/* masked */
neighbors &= ~NTOP;
}
}
if (neighbors & NBOT) {
if (BM_get(gs->curmask, dcol, drow + gs->y_mod)) {
/* masked */
neighbors &= ~NBOT;
}
}
if (neighbors & NLFT) {
if (BM_get(gs->curmask, dcol - gs->x_mod, drow)) {
/* masked */
neighbors &= ~NLFT;
}
}
if (neighbors & NRGT) {
if (BM_get(gs->curmask, dcol + gs->x_mod, drow)) {
/* masked */
neighbors &= ~NRGT;
}
}
}
if (!neighbors) {
/* none */
return (0);
}
noffset = DRC2OFF(gs, drow, dcol);
if (!GET_MAPATT(elbuf, noffset, z0)) {
return (0);
}
z1 = z2 = z3 = z4 = z0;
/* we know these aren't null now, maybe use faster GET_MAPATT? */
if (neighbors & NRGT) {
GET_MAPATT(elbuf, noffset + gs->x_mod, z1);
if (!(neighbors & NLFT)) {
z2 = z0 + (z0 - z1);
}
}
if (neighbors & NLFT) {
GET_MAPATT(elbuf, noffset - gs->x_mod, z2);
if (!(neighbors & NRGT)) {
z1 = z0 + (z0 - z2);
}
}
if (neighbors & NTOP) {
GET_MAPATT(elbuf, noffset - slice, z4);
if (!(neighbors & NBOT)) {
z3 = z0 + (z0 - z4);
}
}
if (neighbors & NBOT) {
GET_MAPATT(elbuf, noffset + slice, z3);
if (!(neighbors & NTOP)) {
z4 = z0 + (z0 - z3);
}
}
SET_NORM(norm[noffset]);
return (1);
}
