Example #1
0
    void SBTopHat::SBTopHatImpl::fillKImage(ImageView<std::complex<double> > im,
                                            double kx0, double dkx, int izero,
                                            double ky0, double dky, int jzero) const
    {
        dbg<<"SBTopHat fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<", izero = "<<izero<<std::endl;
        dbg<<"ky = "<<ky0<<" + j * "<<dky<<", jzero = "<<jzero<<std::endl;
        if (izero != 0 || jzero != 0) {
            xdbg<<"Use Quadrant\n";
            fillKImageQuadrant(im,kx0,dkx,izero,ky0,dky,jzero);
        } else {
            xdbg<<"Non-Quadrant\n";
            const int m = im.getNCol();
            const int n = im.getNRow();
            std::complex<double>* ptr = im.getData();
            int skip = im.getNSkip();
            assert(im.getStep() == 1);

            kx0 *= _r0;
            dkx *= _r0;
            ky0 *= _r0;
            dky *= _r0;

            for (int j=0; j<n; ++j,ky0+=dky,ptr+=skip) {
                double kx = kx0;
                double kysq = ky0*ky0;
                for (int i=0; i<m; ++i,kx+=dkx)
                    *ptr++ = kValue2(kx*kx + kysq);
            }
        }
    }
Example #2
0
    void SBTopHat::SBTopHatImpl::fillKImage(ImageView<std::complex<double> > im,
                                            double kx0, double dkx, double dkxy,
                                            double ky0, double dky, double dkyx) const
    {
        dbg<<"SBTopHat fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<" + j * "<<dkxy<<std::endl;
        dbg<<"ky = "<<ky0<<" + i * "<<dkyx<<" + j * "<<dky<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        std::complex<double>* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        kx0 *= _r0;
        dkx *= _r0;
        dkxy *= _r0;
        ky0 *= _r0;
        dky *= _r0;
        dkyx *= _r0;

        for (int j=0; j<n; ++j,kx0+=dkxy,ky0+=dky) {
            double kx = kx0;
            double ky = ky0;
            for (int i=0; i<m; ++i,kx+=dkx,ky+=dkyx)
                *ptr++ = kValue2(kx*kx + ky*ky);
        }
    }
Example #3
0
    void SBGaussian::SBGaussianImpl::fillXImage(ImageView<T> im,
                                                double x0, double dx, double dxy,
                                                double y0, double dy, double dyx) const
    {
        dbg<<"SBGaussian fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<" + j * "<<dxy<<std::endl;
        dbg<<"y = "<<y0<<" + i * "<<dyx<<" + j * "<<dy<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        T* ptr = im.getData();
        const int skip = im.getNSkip();
        assert(im.getStep() == 1);

        x0 *= _inv_sigma;
        dx *= _inv_sigma;
        dxy *= _inv_sigma;
        y0 *= _inv_sigma;
        dy *= _inv_sigma;
        dyx *= _inv_sigma;

        for (int j=0; j<n; ++j,x0+=dxy,y0+=dy,ptr+=skip) {
            double x = x0;
            double y = y0;
            for (int i=0; i<m; ++i,x+=dx,y+=dyx)
                *ptr++ = _norm * fmath::expd( -0.5 * (x*x + y*y) );
        }
    }
Example #4
0
    void SBTopHat::SBTopHatImpl::fillXImage(ImageView<double> im,
                                            double x0, double dx, double dxy,
                                            double y0, double dy, double dyx) const
    {
        dbg<<"SBTopHat fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<" + j * "<<dxy<<std::endl;
        dbg<<"y = "<<y0<<" + i * "<<dyx<<" + j * "<<dy<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        for (int j=0; j<n; ++j,x0+=dxy,y0+=dy,ptr+=skip) {
            double x = x0;
            double y = y0;
            int i=0;
            // Use the fact that any slice through the circle has only one segment that is non-zero.
            // So start with zeroes until in the circle, then _norm, then more zeroes.
            // Note: this could be sped up somewhat using the same kind of calculation we did
            // for the non-sheared fillXImage (the one with izero, jzero), but I didn't
            // bother.  This is probably plenty fast enough for as often as the function is
            // called (i.e. almost never!)
            for (;i<m && (x*x+y*y > _r0sq); ++i,x+=dx,y+=dyx) ++ptr;
            for (;i<m && (x*x+y*y < _r0sq); ++i,x+=dx,y+=dyx) *ptr++ = _norm;
            for (;i<m; ++i,x+=dx,y+=dyx) ++ptr;
        }
    }
Example #5
0
    void SBShapelet::SBShapeletImpl::fillKImage(ImageView<std::complex<double> > im,
                                                double kx0, double dkx, int izero,
                                                double ky0, double dky, int jzero) const
    {
        dbg<<"SBShapelet fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<", izero = "<<izero<<std::endl;
        dbg<<"ky = "<<ky0<<" + j * "<<dky<<", jzero = "<<jzero<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        std::complex<double>* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        kx0 *= _sigma;
        dkx *= _sigma;
        ky0 *= _sigma;
        dky *= _sigma;

        tmv::Matrix<double> mkx(m,n);
        for (int i=0; i<m; ++i,kx0+=dkx) mkx.row(i).setAllTo(kx0);
        tmv::Matrix<double> mky(m,n);
        for (int j=0; j<n; ++j,ky0+=dky) mky.col(j).setAllTo(ky0);

        tmv::Matrix<std::complex<double> > val(m,n);
        fillKValue(val.view(),mkx,mky);

        typedef tmv::VIt<std::complex<double>,1,tmv::NonConj> CIt;
        CIt valit = val.linearView().begin();
        for (int j=0; j<n; ++j,ptr+=skip) {
            for (int i=0; i<m; ++i)
                *ptr++ = *valit++;
        }
     }
Example #6
0
    void SBBox::SBBoxImpl::fillKImage(ImageView<std::complex<double> > im,
                                                double kx0, double dkx, double dkxy,
                                                double ky0, double dky, double dkyx) const
    {
        dbg<<"SBBox fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<" + j * "<<dkxy<<std::endl;
        dbg<<"ky = "<<ky0<<" + i * "<<dkyx<<" + j * "<<dky<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        std::complex<double>* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        kx0 *= _wo2pi;
        dkx *= _wo2pi;
        dkxy *= _wo2pi;
        ky0 *= _ho2pi;
        dky *= _ho2pi;
        dkyx *= _ho2pi;

        for (int j=0; j<n; ++j,kx0+=dkxy,ky0+=dky,ptr+=skip) {
            double kx = kx0;
            double ky = ky0;
            for (int i=0; i<m; ++i,kx+=dkx,ky+=dkyx) {
                *ptr++ = _flux * sinc(kx) * sinc(ky);
            }
        }
    }
Example #7
0
    void SBSpergel::SBSpergelImpl::fillXImage(ImageView<double> im,
                                              double x0, double dx, double dxy,
                                              double y0, double dy, double dyx) const
    {
        dbg<<"SBSpergel fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<" + j * "<<dxy<<std::endl;
        dbg<<"y = "<<y0<<" + i * "<<dyx<<" + j * "<<dy<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        const int skip = im.getNSkip();
        assert(im.getStep() == 1);

        x0 *= _inv_r0;
        dx *= _inv_r0;
        dxy *= _inv_r0;
        y0 *= _inv_r0;
        dy *= _inv_r0;
        dyx *= _inv_r0;

        for (int j=0; j<n; ++j,x0+=dxy,y0+=dy,ptr+=skip) {
            double x = x0;
            double y = y0;
            for (int i=0; i<m; ++i,x+=dx,y+=dyx)
                *ptr++ = _xnorm * _info->xValue(sqrt(x*x + y*y));
        }
    }
Example #8
0
    void SBBox::SBBoxImpl::fillXImage(ImageView<double> im,
                                      double x0, double dx, double dxy,
                                      double y0, double dy, double dyx) const
    {
        dbg<<"SBBox fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<" + j * "<<dxy<<std::endl;
        dbg<<"y = "<<y0<<" + i * "<<dyx<<" + j * "<<dy<<std::endl;

        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        const int skip = im.getNSkip();
        assert(im.getStep() == 1);

        for (int j=0;j<n;++j,x0+=dxy,y0+=dy,ptr+=skip) {
            double x = x0;
            double y = y0;
            int i=0;
            // Use the fact that any slice through the box has only one segment that is non-zero.
            // So start with zeroes until in the box (already there), then _norm, then more zeroes.
            for (;i<m && (std::abs(x)>_wo2 || std::abs(y)>_ho2); ++i,x+=dx,y+=dyx)
                ++ptr;
            for (;i<m && std::abs(x)<_wo2 && std::abs(y)<_ho2; ++i,x+=dx,y+=dyx)
                *ptr++ = _norm;
            for (;i<m; ++i,x+=dx,y+=dyx)
                ++ptr;
        }
    }
Example #9
0
    void SBSpergel::SBSpergelImpl::fillXImage(ImageView<double> im,
                                              double x0, double dx, int izero,
                                              double y0, double dy, int jzero) const
    {
        dbg<<"SBSpergel fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<", izero = "<<izero<<std::endl;
        dbg<<"y = "<<y0<<" + j * "<<dy<<", jzero = "<<jzero<<std::endl;
        if (izero != 0 || jzero != 0) {
            xdbg<<"Use Quadrant\n";
            fillXImageQuadrant(im,x0,dx,izero,y0,dy,jzero);
        } else {
            xdbg<<"Non-Quadrant\n";
            const int m = im.getNCol();
            const int n = im.getNRow();
            double* ptr = im.getData();
            const int skip = im.getNSkip();
            assert(im.getStep() == 1);

            x0 *= _inv_r0;
            dx *= _inv_r0;
            y0 *= _inv_r0;
            dy *= _inv_r0;

            for (int j=0; j<n; ++j,y0+=dy,ptr+=skip) {
                double x = x0;
                double ysq = y0*y0;
                for (int i=0; i<m; ++i,x+=dx)
                    *ptr++ = _xnorm * _info->xValue(sqrt(x*x + ysq));
            }
        }
    }
Example #10
0
    void SBGaussian::SBGaussianImpl::fillKImage(ImageView<std::complex<T> > im,
                                                double kx0, double dkx, double dkxy,
                                                double ky0, double dky, double dkyx) const
    {
        dbg<<"SBGaussian fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<" + j * "<<dkxy<<std::endl;
        dbg<<"ky = "<<ky0<<" + i * "<<dkyx<<" + j * "<<dky<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        std::complex<T>* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        kx0 *= _sigma;
        dkx *= _sigma;
        dkxy *= _sigma;
        ky0 *= _sigma;
        dky *= _sigma;
        dkyx *= _sigma;

        for (int j=0; j<n; ++j,kx0+=dkxy,ky0+=dky,ptr+=skip) {
            double kx = kx0;
            double ky = ky0;
            for (int i=0; i<m; ++i,kx+=dkx,ky+=dkyx) {
                double ksq = kx*kx + ky*ky;
                if (ksq > _ksq_max) {
                    *ptr++ = 0.;
                } else if (ksq < _ksq_min) {
                    *ptr++ = _flux * (1. - 0.5*ksq*(1. - 0.25*ksq));
                } else {
                    *ptr++ =  _flux * fmath::expd(-0.5*ksq);
                }
            }
        }
    }
Example #11
0
    void SBShapelet::SBShapeletImpl::fillXImage(ImageView<double> im,
                                                double x0, double dx, int izero,
                                                double y0, double dy, int jzero) const
    {
        dbg<<"SBShapelet fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<", izero = "<<izero<<std::endl;
        dbg<<"y = "<<y0<<" + j * "<<dy<<", jzero = "<<jzero<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        const int skip = im.getNSkip();
        assert(im.getStep() == 1);

        x0 /= _sigma;
        dx /= _sigma;
        y0 /= _sigma;
        dy /= _sigma;

        tmv::Matrix<double> mx(m,n);
        for (int i=0; i<m; ++i,x0+=dx) mx.row(i).setAllTo(x0);
        tmv::Matrix<double> my(m,n);
        for (int j=0; j<n; ++j,y0+=dy) my.col(j).setAllTo(y0);

        tmv::Matrix<double> val(m,n);
        fillXValue(val.view(),mx,my);

        typedef tmv::VIt<double,1,tmv::NonConj> It;
        It valit = val.linearView().begin();
        for (int j=0; j<n; ++j,ptr+=skip) {
            for (int i=0; i<m; ++i)
                *ptr++ = *valit++;
        }
    }
Example #12
0
    void SBTopHat::SBTopHatImpl::fillXImage(ImageView<double> im,
                                            double x0, double dx, int izero,
                                            double y0, double dy, int jzero) const
    {
        dbg<<"SBTopHat fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<", izero = "<<izero<<std::endl;
        dbg<<"y = "<<y0<<" + j * "<<dy<<", jzero = "<<jzero<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        // The columns to consider have -r0 <= y < r0
        // given that y = y0 + j dy
        double absdx = std::abs(dx);
        double absdy = std::abs(dy);
        int j1 = std::max(0, int(std::ceil(-_r0/absdy - y0/dy)));
        int j2 = std::min(n, int(std::ceil(_r0/absdy - y0/dy)));
        y0 += j1 * dy;
        ptr += j1*im.getStride();

        for (int j=j1; j<j2; ++j,y0+=dy,ptr+=skip) {
            double ysq = y0*y0;
            double xmax = std::sqrt(_r0sq - ysq);
            // Set to _norm all pixels with -xmax <= x < xmax
            // given that x = x0 + i dx.
            int i1 = std::max(0, int(std::ceil(-xmax/absdx - x0/dx)));
            int i2 = std::min(m, int(std::ceil(xmax/absdx - x0/dx)));
            int i=0;
            for (; i<i1; ++i) ++ptr;
            for (; i<i2; ++i) *ptr++ = _norm;
            for (; i<m; ++i) ++ptr;
        }
    }
Example #13
0
    void SBGaussian::SBGaussianImpl::fillKImage(ImageView<std::complex<T> > im,
                                                double kx0, double dkx, int izero,
                                                double ky0, double dky, int jzero) const
    {
        dbg<<"SBGaussian fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<", izero = "<<izero<<std::endl;
        dbg<<"ky = "<<ky0<<" + j * "<<dky<<", jzero = "<<jzero<<std::endl;
        if (izero != 0 || jzero != 0) {
            xdbg<<"Use Quadrant\n";
            fillKImageQuadrant(im,kx0,dkx,izero,ky0,dky,jzero);
        } else {
            xdbg<<"Non-Quadrant\n";
            const int m = im.getNCol();
            const int n = im.getNRow();
            std::complex<T>* ptr = im.getData();
            int skip = im.getNSkip();
            assert(im.getStep() == 1);

            kx0 *= _sigma;
            dkx *= _sigma;
            ky0 *= _sigma;
            dky *= _sigma;

            // The Gaussian profile is separable:
            //    im(kx,ky) = _flux * exp(-0.5 * (kx*kx + ky*ky)
            //              = _flux * exp(-0.5 * kx*kx) * exp(-0.5 * ky*ky)
            std::vector<double> gauss_kx(m);
            std::vector<double> gauss_ky(n);
            typedef std::vector<double>::iterator It;
            It kxit = gauss_kx.begin();

            for (int i=0; i<m; ++i,kx0+=dkx) *kxit++ = fmath::expd(-0.5 * kx0*kx0);

            if ((kx0 == ky0) && (dkx == dky) && (m==n)) {
                gauss_ky = gauss_kx;
            } else {
                It kyit = gauss_ky.begin();
                for (int j=0; j<n; ++j,ky0+=dky) *kyit++ = fmath::expd(-0.5 * ky0*ky0);
            }

            for (int j=0; j<n; ++j,ptr+=skip) {
                for (int i=0; i<m; ++i)
                    *ptr++ = _flux * gauss_kx[i] * gauss_ky[j];
            }
        }
    }
Example #14
0
    void SBGaussian::SBGaussianImpl::fillXImage(ImageView<T> im,
                                                double x0, double dx, int izero,
                                                double y0, double dy, int jzero) const
    {
        dbg<<"SBGaussian fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<", izero = "<<izero<<std::endl;
        dbg<<"y = "<<y0<<" + j * "<<dy<<", jzero = "<<jzero<<std::endl;
        if (izero != 0 || jzero != 0) {
            xdbg<<"Use Quadrant\n";
            fillXImageQuadrant(im,x0,dx,izero,y0,dy,jzero);
        } else {
            xdbg<<"Non-Quadrant\n";
            const int m = im.getNCol();
            const int n = im.getNRow();
            T* ptr = im.getData();
            const int skip = im.getNSkip();
            assert(im.getStep() == 1);

            x0 *= _inv_sigma;
            dx *= _inv_sigma;
            y0 *= _inv_sigma;
            dy *= _inv_sigma;

            // The Gaussian profile is separable:
            //    im(x,y) = _norm * exp(-0.5 * (x*x + y*y)
            //            = _norm * exp(-0.5 * x*x) * exp(-0.5 * y*y)
            std::vector<double> gauss_x(m);
            std::vector<double> gauss_y(n);
            typedef std::vector<double>::iterator It;
            It xit = gauss_x.begin();
            for (int i=0; i<m; ++i,x0+=dx) *xit++ = fmath::expd(-0.5 * x0*x0);

            if ((x0 == y0) && (dx == dy) && (m==n)) {
                gauss_y = gauss_x;
            } else {
                It yit = gauss_y.begin();
                for (int j=0; j<n; ++j,y0+=dy) *yit++ = fmath::expd(-0.5 * y0*y0);
            }

            for (int j=0; j<n; ++j,ptr+=skip) {
                for (int i=0; i<m; ++i)
                    *ptr++ = _norm * gauss_x[i] * gauss_y[j];
            }
        }
    }
Example #15
0
    void SBBox::SBBoxImpl::fillKImage(ImageView<std::complex<double> > im,
                                      double kx0, double dkx, int izero,
                                      double ky0, double dky, int jzero) const
    {
        dbg<<"SBBox fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<", izero = "<<izero<<std::endl;
        dbg<<"ky = "<<ky0<<" + j * "<<dky<<", jzero = "<<jzero<<std::endl;
        if (izero != 0 || jzero != 0) {
            xdbg<<"Use Quadrant\n";
            fillKImageQuadrant(im,kx0,dkx,izero,ky0,dky,jzero);
        } else {
            xdbg<<"Non-Quadrant\n";
            const int m = im.getNCol();
            const int n = im.getNRow();
            std::complex<double>* ptr = im.getData();
            int skip = im.getNSkip();
            assert(im.getStep() == 1);

            kx0 *= _wo2pi;
            dkx *= _wo2pi;
            ky0 *= _ho2pi;
            dky *= _ho2pi;

            // The Box profile in Fourier space is separable:
            //    val(x,y) = _flux * sinc(x * _width/2pi) * sinc(y * _height/2pi)
            std::vector<double> sinc_kx(m);
            std::vector<double> sinc_ky(n);
            typedef std::vector<double>::iterator It;
            It kxit = sinc_kx.begin();
            for (int i=0; i<m; ++i,kx0+=dkx) *kxit++ = sinc(kx0);

            if ((kx0 == ky0) && (dkx == dky) && (m==n)) {
                sinc_ky = sinc_kx;
            } else {
                It kyit = sinc_ky.begin();
                for (int j=0; j<n; ++j,ky0+=dky) *kyit++ = sinc(ky0);
            }

            for (int j=0; j<n; ++j,ptr+=skip) {
                for (int i=0; i<m; ++i)
                    *ptr++ = _flux * sinc_kx[i] * sinc_ky[j];
            }
        }
    }
Example #16
0
    void SBShapelet::SBShapeletImpl::fillKImage(ImageView<std::complex<double> > im,
                                                double kx0, double dkx, double dkxy,
                                                double ky0, double dky, double dkyx) const
    {
        dbg<<"SBShapelet fillKImage\n";
        dbg<<"kx = "<<kx0<<" + i * "<<dkx<<" + j * "<<dkxy<<std::endl;
        dbg<<"ky = "<<ky0<<" + i * "<<dkyx<<" + j * "<<dky<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        std::complex<double>* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        kx0 *= _sigma;
        dkx *= _sigma;
        dkxy *= _sigma;
        ky0 *= _sigma;
        dky *= _sigma;
        dkyx *= _sigma;

        tmv::Matrix<double> mkx(m,n);
        tmv::Matrix<double> mky(m,n);
        typedef tmv::VIt<double,1,tmv::NonConj> It;
        It kxit = mkx.linearView().begin();
        It kyit = mky.linearView().begin();
        for (int j=0; j<n; ++j,kx0+=dkxy,ky0+=dky) {
            double kx = kx0;
            double ky = ky0;
            for (int i=0; i<m; ++i,kx+=dkx,ky+=dkyx) { *kxit++ = kx; *kyit++ = ky; }
        }

        tmv::Matrix<std::complex<double> > val(m,n);
        fillKValue(val.view(),mkx,mky);

        typedef tmv::VIt<std::complex<double>,1,tmv::NonConj> CIt;
        CIt valit = val.linearView().begin();
        for (int j=0; j<n; ++j,ptr+=skip) {
            for (int i=0; i<m; ++i)
                *ptr++ = *valit++;
        }
    }
Example #17
0
    void SBShapelet::SBShapeletImpl::fillXImage(ImageView<double> im,
                                                double x0, double dx, double dxy,
                                                double y0, double dy, double dyx) const
    {
        dbg<<"SBShapelet fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<" + j * "<<dxy<<std::endl;
        dbg<<"y = "<<y0<<" + i * "<<dyx<<" + j * "<<dy<<std::endl;
        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        const int skip = im.getNSkip();
        assert(im.getStep() == 1);

        x0 /= _sigma;
        dx /= _sigma;
        dxy /= _sigma;
        y0 /= _sigma;
        dy /= _sigma;
        dyx /= _sigma;

        tmv::Matrix<double> mx(m,n);
        tmv::Matrix<double> my(m,n);
        typedef tmv::VIt<double,1,tmv::NonConj> It;
        It xit = mx.linearView().begin();
        It yit = my.linearView().begin();
        for (int j=0; j<n; ++j,x0+=dxy,y0+=dy) {
            double x = x0;
            double y = y0;
            for (int i=0; i<m; ++i,x+=dx,y+=dyx) { *xit++ = x; *yit++ = y; }
        }

        tmv::Matrix<double> val(m,n);
        fillXValue(val.view(),mx,my);

        It valit = val.linearView().begin();
        for (int j=0; j<n; ++j,ptr+=skip) {
            for (int i=0; i<m; ++i)
                *ptr++ = *valit++;
        }
    }
Example #18
0
    void SBBox::SBBoxImpl::fillXImage(ImageView<double> im,
                                      double x0, double dx, int izero,
                                      double y0, double dy, int jzero) const
    {
        dbg<<"SBBox fillXImage\n";
        dbg<<"x = "<<x0<<" + i * "<<dx<<", izero = "<<izero<<std::endl;
        dbg<<"y = "<<y0<<" + j * "<<dy<<", jzero = "<<jzero<<std::endl;

        const int m = im.getNCol();
        const int n = im.getNRow();
        double* ptr = im.getData();
        int skip = im.getNSkip();
        assert(im.getStep() == 1);

        x0 /= dx;
        double wo2 = _wo2 / std::abs(dx);
        y0 /= dy;
        double ho2 = _ho2 / std::abs(dy);

        // Fill the interior with _norm:
        // Fill pixels where:
        //     x0 + i >= -width/2
        //     x0 + i < width/2
        //     y0 + j >= -width/2
        //     y0 + j < width/2

        int i1 = std::max(0, int(std::ceil(-wo2 - x0)));
        int i2 = std::min(m, int(std::ceil(wo2 - x0)));
        int j1 = std::max(0, int(std::ceil(-ho2 - y0)));
        int j2 = std::min(n, int(std::ceil(ho2 - y0)));

        ptr += im.getStride() * j1 + i1;
        skip += m - (i2-i1);

        for (int j=j1; j<j2; ++j,ptr+=skip) {
            for (int i=i1;i<i2;++i)
                *ptr++ = _norm;
        }
    }