hi, kiirala,

could you please take a look at this code? It is an attempt to fix the current displacement map render implementation. I am not sure whether I am dealing with the in and out buffers the proper way. The problem is that I need to handle buffers with different sizes.

(dont know why, this code segfaults)

Juca

/*
 * feDisplacementMap filter primitive renderer
 *
 * Authors:
 *   Felipe Corrêa da Silva Sanches < felipe.sanches@...400...>
 *
 * Copyright (C) 2007 authors
 *
 * Released under GNU GPL, read the file 'COPYING' for more information
 */

#include "display/nr-filter-displacement-map.h "
#include "display/nr-filter-types.h"
#include "libnr/nr-pixops.h"

namespace NR {

FilterDisplacementMap::FilterDisplacementMap()
: scale(0),
  _input2(NR_FILTER_SLOT_NOT_SET),
   Xchannel(3),
  Ychannel(3)
{}

FilterPrimitive * FilterDisplacementMap::create() {
    return new FilterDisplacementMap();
}

FilterDisplacementMap::~FilterDisplacementMap()
{}

int FilterDisplacementMap::render(FilterSlot &slot, Matrix const &trans) {
    g_warning("FIX-ME: FilterDisplacementMap::render method is still a bit buggy. Needs Love.");
    
    NRPixBlock *texture = slot.get(_input);
    NRPixBlock *map = slot.get(_input2);
    NRPixBlock *out = new NRPixBlock;
    
    // Bail out if either one of source images is missing
    if (!map || !texture) {
        g_warning("Missing source image for feDisplacementMap (map=%d texture=%d)", _input, _input2);
        return 1;
    }

    int x, y;
    int in_x0 = map->area.x0, in_y0 = map->area.x0;
    int in_x1 = map->area.x1, in_y1 = map->area.y1;
    int out_x0 = in_x0 + scale/2, out_y0 = in_y0 + scale/2;
    int out_x1 = in_x1 - scale/2, out_y1 = in_y1 - scale/2;
    int in_w = in_x1 - in_x0;
    int out_w = out_x1 - out_x0;
    double coordx, coordy;
        
    nr_pixblock_setup_fast(out, map->mode, out_x0, out_y0, out_x1, out_y1, true);

    unsigned char *map_data = NR_PIXBLOCK_PX(map);
    unsigned char *texture_data = NR_PIXBLOCK_PX(texture);
    unsigned char *out_data = NR_PIXBLOCK_PX(out);

    for (x = out_x0; x < out_x1; x++){
        for (y = out_y0; y < out_y1; y++){

            coordx = x-in_x0 + scale * ( ((double) map_data[4*((x-in_x0) + in_w*(y-in_y0)) + Xchannel])/255 - 0.5 );
            coordy = y-in_y0 + scale * ( ((double) map_data[4*((x-in_x0) + in_w*(y-in_y0)) + Ychannel])/255 - 0.5 );

            out_data[4*((x-out_x0) + out_w*(y-out_y0))] = texture_data[4*((int)coordx + ((int)coordy)*in_w)];
            out_data[4*((x-out_x0) + out_w*(y-out_y0)) + 1] = texture_data[4*((int)coordx + ((int)coordy)*in_w) + 1];
            out_data[4*((x-out_x0) + out_w*(y-out_y0)) + 2] = texture_data[4*((int)coordx + ((int)coordy)*in_w) + 2];
            out_data[4*((x-out_x0) + out_w*(y-out_y0)) + 3] = texture_data[4*((int)coordx + ((int)coordy)*in_w) + 3];
        }
    }

    out->empty = FALSE;
    slot.set(_output, out);
            return 0;
}

void FilterDisplacementMap::set_input(int slot) {
    _input = slot;
}

void FilterDisplacementMap::set_scale(double s) {
    scale = s;
}

void FilterDisplacementMap::set_input(int input, int slot) {
    if (input == 0) _input = slot;
    if (input == 1) _input2 = slot;
}

void FilterDisplacementMap::set_channel_selector(int s, int channel) {
    if (s == 0) Xchannel = channel;
    if (s == 1) Ychannel = channel;
}

void FilterDisplacementMap::area_enlarge(NRRectL &area, Matrix const &trans)
{
    //I'm in doubt whether this affects all input buffers or only 'in'
    area.x0 -= (int)(scale/2);
    area.y0 -= (int)(scale/2);
    area.x1 += (int)(scale/2);
    area.y1 += (int)(scale/2);
}

} /* namespace NR */

/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :