libpyarr/misc.cpp at master · LAIRLAB/libpyarr · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include "misc.h"
#include <cmath>
#include <cstdio>
#include <cstring>

real find_frac(real fs, real ratio,
               real *fd_low, real *fd_high)
{
    *fd_low = round(fs/ratio - 0.5);
    *fd_high = round((fs + 1.0)/ratio - 0.5);

    real fs_boundary = (*fd_low + 1.0)*ratio - 0.5;

    real fd_frac = 0.0;

    if (fs - 0.5 < fs_boundary &&
	fs + 0.5 >= fs_boundary) {
	fd_frac = (fs + 0.5) - fs_boundary;
    }
    return fd_frac;
}

void shrink_bilinear(real *src, int sh, int sw,
		     real *dst, int dh, int dw, int depth)
{
    real fsi = 0.0;
    real fsj = 0.0;
    real fsh = (real)sh;
    real fsw = (real)sw;
    real fdh = (real)dh;
    real fdw = (real)dw;

    real hratio = fsh/fdh;
    real wratio = fsw/fdw;

    memset((void*)dst, 0, dh*dw*depth*sizeof(real));

    for (int si=0; si<sh; si++) {
        fsi = real(si);

	real fdi_low, fdi_high;
	real fdi_frac = find_frac(fsi, hratio,
                                  &fdi_low, &fdi_high);
	int di_low = max(0, min(dh-1, int(fdi_low)));
	int di_high = max(0, min(dh-1, int(fdi_high)));

	real fdi_frac1m = 1.0 - fdi_frac;

	for (int sj=0; sj<sw; sj++) {
            fsj = real(sj);
	    real fdj_low, fdj_high;
	    real fdj_frac = find_frac(fsj, wratio,
					&fdj_low, &fdj_high);

	    int dj_low = max(0, min(dw-1, int(fdj_low)));
	    int dj_high = max(0, min(dw-1, int(fdj_high)));

	    real fdj_frac1m = 1.0 - fdj_frac;


	    for (int k=0; k<depth; k++) {

		real src_val = src[si*sw*depth + sj*depth + k]/(hratio*wratio);

		dst[di_low*dw*depth + dj_low*depth + k] += fdi_frac1m * fdj_frac1m * src_val;
		if (fdj_frac)
		    dst[di_low*dw*depth + dj_high*depth + k] += fdi_frac1m * fdj_frac *  src_val;
		if (fdi_frac) {
		    dst[di_high*dw*depth + dj_low*depth + k] += fdi_frac * fdj_frac1m *  src_val;
		    if (fdj_frac)
			dst[di_high*dw*depth + dj_high*depth + k] += fdi_frac * fdj_frac *   src_val;
		}
	    }
	}
    }
}

void expand_bilinear(real *src, int sh, int sw,
                     real *dst, int dh, int dw, int depth)
{
    real fdi = 0.0;
    real fdj = 0.0;
    real fsh = (real)sh;
    real fsw = (real)sw;
    real fdh = (real)dh;
    real fdw = (real)dw;

    real hratio = fdh/fsh;
    real wratio = fdw/fsw;

    memset((void*)dst, 0, dh*dw*depth*sizeof(real));

    for (int di=0; di<dh; di++) {
        fdi = real(di);

	real fsi_low, fsi_high;
	real fsi_frac = find_frac(fdi, hratio,
                                  &fsi_low, &fsi_high);

	int si_low = max(0, min(sh-1, int(fsi_low)));
	int si_high = max(0, min(sh-1, int(fsi_high)));

	real fsi_frac1m = 1.0 - fsi_frac;

        for (int dj=0; dj<dw; dj++) {
            fdj = real(dj);
            real fsj_low, fsj_high;
            real fsj_frac = find_frac(fdj, wratio,
                                      &fsj_low, &fsj_high);

            int sj_low = max(0, min(sw-1, int(fsj_low)));
            int sj_high = max(0, min(sw-1, int(fsj_high)));

            real fsj_frac1m = 1.0 - fsj_frac;

	    for (int k=0; k<depth; k++) {
                real dstsum = 0.0;

                dstsum += fsi_frac1m * fsj_frac1m * src[si_low*sw*depth + sj_low*depth + k];
		if (fsj_frac)
		    dstsum += fsi_frac1m * fsj_frac * src[si_low*sw*depth + sj_high*depth + k];
		if (fsi_frac) {
		    dstsum += fsi_frac * fsj_frac1m * src[si_high*sw*depth + sj_low*depth + k];
		    if (fsj_frac)
			dstsum += fsi_frac * fsj_frac * src[si_high*sw*depth + sj_high*depth + k];
		}

                dst[di*dw*depth + dj*depth + k] += dstsum;

	    }
        }
    }
}