Skip to content
Permalink
Browse files

Implement chainable compositing filters (RFC113)

  • Loading branch information...
tbonfort committed Sep 30, 2015
1 parent 0241ceb commit 4521ccfdc9c743e266d40134af158bad128df68c
Showing with 409 additions and 21 deletions.
  1. +2 −1 CMakeLists.txt
  2. +5 −0 HISTORY.TXT
  3. +2 −7 mapagg.cpp
  4. +223 −0 mapcompositingfilter.c
  5. +21 −1 mapcopy.c
  6. +15 −6 mapdraw.c
  7. +136 −4 mapfile.c
  8. +5 −2 mapserver.h
@@ -262,7 +262,8 @@ mapogcfiltercommon.c maprendering.c mapwcs20.c mapogcsld.c
mapresample.c mapwfs.c mapgdal.c mapogcsos.c mapscale.c mapwfs11.c mapwfs20.c
mapgeomtransform.c mapogroutput.c mapwfslayer.c mapagg.cpp mapkml.cpp
mapgeomutil.cpp mapkmlrenderer.cpp fontcache.c textlayout.c maputfgrid.cpp
mapogr.cpp mapcontour.c mapsmoothing.c mapv8.cpp ${REGEX_SOURCES} kerneldensity.c)
mapogr.cpp mapcontour.c mapsmoothing.c mapv8.cpp ${REGEX_SOURCES} kerneldensity.c
mapcompositingfilter.c)

set(mapserver_HEADERS
cgiutil.h dejavu-sans-condensed.h dxfcolor.h fontcache.h hittest.h mapagg.h
@@ -10,6 +10,11 @@ the top of the list.)

For a complete change history, please see the Git log comments.

7.2 release (FUTURE)
--------------------

- Implement chainable compositing filters (RFC113)

7.0.0 release (2015/07/24)
--------------------------

@@ -1333,15 +1333,10 @@ int aggCompositeRasterBuffer(imageObj *dest, rasterBufferObj *overlay, Compositi
#endif
}

rasterBufferObj* msApplyFilterToRasterBuffer(const rasterBufferObj *rb, CompositingFilter *filter) {
rasterBufferObj *rbret = (rasterBufferObj*)msSmallCalloc(sizeof(rasterBufferObj),1);
msCopyRasterBuffer(rbret,rb);
rendering_buffer b(rbret->data.rgba.pixels, rbret->width, rbret->height, rbret->data.rgba.row_step);
void msApplyBlurringCompositingFilter(rasterBufferObj *rb, unsigned int radius) {
rendering_buffer b(rb->data.rgba.pixels, rb->width, rb->height, rb->data.rgba.row_step);
pixel_format pf(b);
/* for now, we only support a blurring filter */
int radius = atoi(filter->filter);
mapserver::stack_blur_rgba32(pf,radius,radius);
return rbret;
}

int msPopulateRendererVTableAGG(rendererVTableObj * renderer)
@@ -0,0 +1,223 @@
/******************************************************************************
*
* Project: MapServer
* Purpose: RFC 113 Layer compositing
* Author: Thomas Bonfort and the MapServer team.
*
******************************************************************************
* Copyright (c) 1996-2015 Regents of the University of Minnesota.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "mapserver.h"
#include <regex.h>
#define pixmove(rb,srcx,srcy,dstx,dsty) \
memcpy(rb->data.rgba.pixels+dsty*rb->data.rgba.row_step+dstx*4,\
rb->data.rgba.pixels+srcy*rb->data.rgba.row_step+srcx*4,\
4)
#define pixerase(rb,x,y) memset(rb->data.rgba.pixels+y*rb->data.rgba.row_step+x*4,0,4)

void msApplyTranslationCompositingFilter(rasterBufferObj *rb, int xtrans, int ytrans) {
int src_sx,src_sy,dst_sx,dst_sy,x,y,dst_x,dst_y;
if(abs(xtrans)>=rb->width || abs(ytrans)>=rb->height) {
for(y = 0; y<rb->height; y++)
for(x = 0; x<rb->width; x++)
pixerase(rb,x,y);
}
if(xtrans == 0 && ytrans == 0)
return;
if(xtrans>=0) {
if(ytrans>=0) {
src_sx = rb->width - xtrans - 1;
src_sy = rb->height - ytrans - 1;
dst_sx = rb->width - 1;
dst_sy = rb->height -1;
for(y = src_sy,dst_y= dst_sy;y>=0;y--,dst_y--) {
for(x = src_sx,dst_x= dst_sx;x>=0;x--,dst_x--) {
pixmove(rb,x,y,dst_x,dst_y);
}
}
for(y=0;y<ytrans;y++)
for(x=0;x<rb->width;x++)
pixerase(rb,x,y);
for(y=ytrans;y<rb->height;y++)
for(x=0;x<xtrans;x++)
pixerase(rb,x,y);
} else {
src_sx = rb->width - xtrans - 1;
src_sy = - ytrans;
dst_sx = rb->width - 1;
dst_sy = 0;
for(y = src_sy,dst_y= dst_sy;y<rb->height;y++,dst_y++) {
for(x = src_sx,dst_x= dst_sx;x>=0;x--,dst_x--) {
pixmove(rb,x,y,dst_x,dst_y);
}
}
for(y=0;y<rb->height+ytrans;y++)
for(x=0;x<xtrans;x++)
pixerase(rb,x,y);
for(y=rb->height+ytrans;y<rb->height;y++)
for(x=0;x<rb->width;x++)
pixerase(rb,x,y);
}
} else {
if(ytrans>=0) {
src_sx = - xtrans;
src_sy = rb->height - ytrans - 1;
dst_sx = 0;
dst_sy = rb->height -1;
for(y = src_sy,dst_y= dst_sy;y>=0;y--,dst_y--) {
for(x = src_sx,dst_x= dst_sx;x<rb->width;x++,dst_x++) {
pixmove(rb,x,y,dst_x,dst_y);
}
}
for(y=0;y<ytrans;y++)
for(x=0;x<rb->width;x++)
pixerase(rb,x,y);
for(y=ytrans;y<rb->height;y++)
for(x=rb->width+xtrans;x<rb->width;x++)
pixerase(rb,x,y);
} else {
src_sx = - xtrans;
src_sy = - ytrans;
dst_sx = 0;
dst_sy = 0;
for(y = src_sy,dst_y= dst_sy;y<rb->height;y++,dst_y++) {
for(x = src_sx,dst_x= dst_sx;x<rb->width;x++,dst_x++) {
pixmove(rb,x,y,dst_x,dst_y);
}
}
for(y=0;y<rb->height+ytrans;y++)
for(x=rb->width+xtrans;x<rb->width;x++)
pixerase(rb,x,y);
for(y=rb->height+ytrans;y<rb->height;y++)
for(x=0;x<rb->width;x++)
pixerase(rb,x,y);
}
}
}

void msApplyBlackeningCompositingFilter(rasterBufferObj *rb) {
int row,col;
unsigned char *r,*g,*b;
for(row=0;row<rb->height;row++) {
r = rb->data.rgba.r + row*rb->data.rgba.row_step;
g = rb->data.rgba.g + row*rb->data.rgba.row_step;
b = rb->data.rgba.b + row*rb->data.rgba.row_step;
for(col=0;col<rb->width;col++) {
*r = *g = *b = 0;
r+=4;g+=4;b+=4;
}
}
}

void msApplyWhiteningCompositingFilter(rasterBufferObj *rb) {
int row,col;
unsigned char *r,*g,*b,*a;
for(row=0;row<rb->height;row++) {
r = rb->data.rgba.r + row*rb->data.rgba.row_step;
g = rb->data.rgba.g + row*rb->data.rgba.row_step;
b = rb->data.rgba.b + row*rb->data.rgba.row_step;
a = rb->data.rgba.a + row*rb->data.rgba.row_step;
for(col=0;col<rb->width;col++) {
*r = *g = *b = *a;
r+=4;g+=4;b+=4;a+=4;
}
}
}

void msApplyGrayscaleCompositingFilter(rasterBufferObj *rb) {
int row,col;
unsigned char *r,*g,*b;
for(row=0;row<rb->height;row++) {
r = rb->data.rgba.r + row*rb->data.rgba.row_step;
g = rb->data.rgba.g + row*rb->data.rgba.row_step;
b = rb->data.rgba.b + row*rb->data.rgba.row_step;
for(col=0;col<rb->width;col++) {
unsigned int mix = (unsigned int)*r + (unsigned int)*g + (unsigned int)*b;
mix /=3;
*r = *g = *b = (unsigned char)mix;
r+=4;g+=4;b+=4;
}
}
}

int msApplyCompositingFilter(mapObj *map, rasterBufferObj *rb, CompositingFilter *filter) {
int rstatus;
regex_t regex;
regmatch_t pmatch[3];

/* test for blurring filter */
regcomp(&regex, "blur\\(([0-9]+)\\)", REG_EXTENDED);
rstatus = regexec(&regex, filter->filter, 2, pmatch, 0);
regfree(&regex);
if(!rstatus) {
char *rad = malloc(pmatch[1].rm_eo - pmatch[1].rm_so + 1);
unsigned int irad;
strncpy(rad,filter->filter+pmatch[1].rm_so,pmatch[1].rm_eo-pmatch[1].rm_so);
rad[pmatch[1].rm_eo - pmatch[1].rm_so]=0;
//msDebug("got blur filter with radius %s\n",rad);
irad = atoi(rad);
free(rad);
irad = MS_NINT(irad*map->resolution/map->defresolution);
msApplyBlurringCompositingFilter(rb,irad);
return MS_SUCCESS;
}

/* test for translation filter */
regcomp(&regex, "translate\\((-?[0-9]+),(-?[0-9]+)\\)", REG_EXTENDED);
rstatus = regexec(&regex, filter->filter, 3, pmatch, 0);
regfree(&regex);
if(!rstatus) {
char *num;
int xtrans,ytrans;
num = malloc(pmatch[1].rm_eo - pmatch[1].rm_so + 1);
strncpy(num,filter->filter+pmatch[1].rm_so,pmatch[1].rm_eo-pmatch[1].rm_so);
num[pmatch[1].rm_eo - pmatch[1].rm_so]=0;
xtrans = atoi(num);
free(num);
num = malloc(pmatch[2].rm_eo - pmatch[2].rm_so + 1);
strncpy(num,filter->filter+pmatch[2].rm_so,pmatch[2].rm_eo-pmatch[2].rm_so);
num[pmatch[2].rm_eo - pmatch[2].rm_so]=0;
ytrans = atoi(num);
free(num);
//msDebug("got translation filter of radius %d,%d\n",xtrans,ytrans);
xtrans = MS_NINT(xtrans*map->resolution/map->defresolution);
ytrans = MS_NINT(ytrans*map->resolution/map->defresolution);
msApplyTranslationCompositingFilter(rb,xtrans,ytrans);
return MS_SUCCESS;
}

/* test for grayscale filter */
if(!strncmp(filter->filter,"grayscale()",strlen("grayscale()"))) {
msApplyGrayscaleCompositingFilter(rb);
return MS_SUCCESS;
}
if(!strncmp(filter->filter,"blacken()",strlen("blacken()"))) {
msApplyBlackeningCompositingFilter(rb);
return MS_SUCCESS;
}
if(!strncmp(filter->filter,"whiten()",strlen("whiten()"))) {
msApplyWhiteningCompositingFilter(rb);
return MS_SUCCESS;
}

msSetError(MS_MISCERR,"unknown compositing filter (%s)", "msApplyCompositingFilter()", filter->filter);
return MS_FAILURE;
}
@@ -925,6 +925,26 @@ int msCopyScaleToken(scaleTokenObj *src, scaleTokenObj *dst) {
return MS_SUCCESS;
}

int msCopyCompositingFilter(CompositingFilter **pdst, CompositingFilter *src) {
CompositingFilter *dst = NULL;
if(!src) {
*pdst = NULL;
return MS_SUCCESS;
}
while(src) {
if(!dst) {
dst = *pdst = msSmallMalloc(sizeof(CompositingFilter));
} else {
dst->next = msSmallMalloc(sizeof(CompositingFilter));
dst = dst->next;
}
dst->filter = msStrdup(src->filter);
dst->next = NULL;
src = src->next;
}
return MS_SUCCESS;
}

int msCopyCompositer(LayerCompositer **ldst, LayerCompositer *src) {
LayerCompositer *dst = NULL;
if(!src) {
@@ -942,7 +962,7 @@ int msCopyCompositer(LayerCompositer **ldst, LayerCompositer *src) {
dst->comp_op = src->comp_op;
dst->opacity = src->opacity;
dst->next = NULL;
/* TODO dst->filter */
msCopyCompositingFilter(&dst->filter, src->filter);
src = src->next;
}
return MS_SUCCESS;
@@ -179,15 +179,24 @@ imageObj *msPrepareImage(mapObj *map, int allow_nonsquare)

}

static int msCompositeRasterBuffer(imageObj *img, rasterBufferObj *rb, LayerCompositer *comp) {
static int msCompositeRasterBuffer(mapObj *map, imageObj *img, rasterBufferObj *rb, LayerCompositer *comp) {
int ret = MS_SUCCESS;
if(MS_IMAGE_RENDERER(img)->compositeRasterBuffer) {
while(comp && ret == MS_SUCCESS) {
rasterBufferObj *rb_ptr = rb;
if(comp->filter) {
rb_ptr = msApplyFilterToRasterBuffer(rb,comp->filter);
}
ret = MS_IMAGE_RENDERER(img)->compositeRasterBuffer(img,rb_ptr,comp->comp_op, comp->opacity);
CompositingFilter *filter = comp->filter;
if(filter && comp->next) {
/* if we have another compositor to apply, then we need to copy the rasterBufferObj. Otherwise
* we can work on it directly */
rb_ptr = (rasterBufferObj*)msSmallCalloc(sizeof(rasterBufferObj),1);
msCopyRasterBuffer(rb_ptr,rb);
}
while(filter && ret == MS_SUCCESS) {
ret = msApplyCompositingFilter(map,rb_ptr,filter);
filter = filter->next;
}
if(ret == MS_SUCCESS)
ret = MS_IMAGE_RENDERER(img)->compositeRasterBuffer(img,rb_ptr,comp->comp_op, comp->opacity);
if(rb_ptr != rb) {
msFreeRasterBuffer(rb_ptr);
msFree(rb_ptr);
@@ -870,7 +879,7 @@ int msDrawLayer(mapObj *map, layerObj *layer, imageObj *image)
/*we have a mask layer with no composition configured, do a nomral blend */
retcode = renderer->mergeRasterBuffer(image,&rb,1.0,0,0,0,0,rb.width,rb.height);
} else {
retcode = msCompositeRasterBuffer(image,&rb,layer->compositer);
retcode = msCompositeRasterBuffer(map,image,&rb,layer->compositer);
}
if(UNLIKELY(retcode == MS_FAILURE)) {
goto imagedraw_cleanup;
Oops, something went wrong.

0 comments on commit 4521ccf

Please sign in to comment.
You can’t perform that action at this time.