Page MenuHome
Differential D13029 Diff 57562 source/blender/geometry/intern/trace_image.cc

Changeset View

Standalone View

View Options

source/blender/geometry/intern/trace_image.cc

  • This file was added.
/* SPDX-License-Identifier: GPL-2.0-or-later */
#include "BKE_geometry_set.hh"
#include "BKE_curve.h"
#include "BKE_curves.hh"
#include "BKE_geometry_set.hh"
#include "BKE_image.h"
#include "IMB_imbuf.h"
#include "IMB_imbuf_types.h"
#include "potracelib.h"
namespace blender::geometry {
constexpr unsigned int BM_WORDSIZE = sizeof(potrace_word);
constexpr unsigned int BM_WORDBITS = 8 * BM_WORDSIZE;
constexpr unsigned int BM_HIBIT = (((potrace_word)1) << (BM_WORDBITS - 1));
constexpr unsigned int BM_ALLBITS = (~(potrace_word)0);
constexpr unsigned int GP_PRIM_DATABUF_SIZE = 5;
/**
* Return new un-initialized trace bitmap
* \param w: Width in pixels
* \param h: Height in pixels
* \return Trace bitmap
*/
static potrace_bitmap_t *ED_gpencil_trace_bitmap_new(int32_t w, int32_t h)
{
int32_t dy = (w + BM_WORDBITS - 1) / BM_WORDBITS;
potrace_bitmap_t *bm = static_cast<potrace_bitmap_t *>(
MEM_mallocN(sizeof(potrace_bitmap_t), __func__));
if (!bm) {
return NULL;
}
bm->w = w;
bm->h = h;
bm->dy = dy;
bm->map = static_cast<potrace_word *>(calloc(h, dy * BM_WORDSIZE));
if (!bm->map) {
free(bm);
return NULL;
}
return bm;
}
/**
* Free a trace bitmap
* \param bm: Trace bitmap
*/
static void ED_gpencil_trace_bitmap_free(const potrace_bitmap_t *bm)
{
if (bm != NULL) {
free(bm->map);
}
MEM_SAFE_FREE(bm);
}
/**
* Return pixel data (rgba) at index
* \param ibuf: ImBuf of the image
* \param idx: Index of the pixel
* \return RGBA value
*/
static float4 pixel_at_index(const ImBuf *ibuf, const int32_t idx)
{
BLI_assert(idx < (ibuf->x * ibuf->y));
if (ibuf->rect_float) {
return float4{&ibuf->rect_float[idx * 4]};
}
float4 col{};
unsigned char *cp = (unsigned char *)(ibuf->rect + idx);
for (int i = 0; i < 4; ++i) {
col[i] = static_cast<float>(cp[i]) / 255.0f;
}
return col;
}
/* Potrace macros for writing individual bitmap pixels. */
#define bm_scanline(bm, y) ((bm)->map + (y) * (bm)->dy)
#define bm_index(bm, x, y) (&bm_scanline(bm, y)[(x) / BM_WORDBITS])
#define bm_mask(x) (BM_HIBIT >> ((x) & (BM_WORDBITS - 1)))
#define bm_range(x, a) ((int)(x) >= 0 && (int)(x) < (a))
#define bm_safe(bm, x, y) (bm_range(x, (bm)->w) && bm_range(y, (bm)->h))
#define BM_USET(bm, x, y) (*bm_index(bm, x, y) |= bm_mask(x))
#define BM_UCLR(bm, x, y) (*bm_index(bm, x, y) &= ~bm_mask(x))
#define BM_UPUT(bm, x, y, b) ((b) ? BM_USET(bm, x, y) : BM_UCLR(bm, x, y))
#define BM_PUT(bm, x, y, b) (bm_safe(bm, x, y) ? BM_UPUT(bm, x, y, b) : 0)
HooglyBooglyUnsubmitted
Not Done
Inline Actions

Personally I'd like to see the code style/quality pushed further here, unless there's a comment that references the place these macros came from.

These macros should become functions at least, and the ED_gpencil part of the function names should be removed.
I get the reasoning for not changing it at all, personally I don't think it's worth it though.

HooglyBoogly: Personally I'd like to see the code style/quality pushed further here, unless there's a comment…
/**
* Convert image to BW bitmap for tracing
* \param ibuf: ImBuf of the image
* \param bm: Trace bitmap
*/
static void ED_gpencil_trace_image_to_bitmap(ImBuf *ibuf,
const potrace_bitmap_t *bm,
const float threshold)
{
for (uint32_t y = 0; y < ibuf->y; y++) {
for (uint32_t x = 0; x < ibuf->x; x++) {
int32_t pixel = (ibuf->x * y) + x;
float4 rgba = pixel_at_index(ibuf, pixel);
/* Get a BW color. */
mul_v3_fl(rgba, rgba[3]);
float color = (rgba[0] + rgba[1] + rgba[2]) / 3.0f;
int32_t bw = (color > threshold) ? 0 : 1;
BM_PUT(bm, x, y, bw);
}
}
}
/**
* Scale correction for Potrace.
* Really, there isn't documented in Potrace about how the scale is calculated,
* but after doing a lot of tests, it looks is using a VGA resolution (640) as a base.
* Maybe there are others ways to get the right scale conversion, but this solution works.
* \param width: image width
* \param height: image height
* \param scale: image scale
*/
static float correct_potrace_scale(int width, int height, float scale)
{
const float fwidth = static_cast<float>(width);
const float fheight = static_cast<float>(height);
float scale_potrace = scale * (640.0f / fwidth) * (fwidth / fheight);
if (width > height) {
scale_potrace *= fheight / fwidth;
}
/* Additional heuristic scale to bring it to sensible values. */
return scale_potrace * 0.008f;
}
/**
Potrace API details: https://potrace.sourceforge.net/potracelib.pdf
*/
static Curves *curve_from_potrace(potrace_state_t *potrace_state, const int resolution)
{
potrace_path_t *path = potrace_state->plist;
Vector<float3> positions;
Vector<float3> leftHandles;
Vector<float3> rightHandles;
Vector<int> offsets;
offsets.append(0);
int curr_offset{};
while (path != nullptr) { // per curve
int num_segments = path->curve.n;
int *tag = path->curve.tag;
auto *control_points = path->curve.c;
for (int32_t i = 0; i < num_segments; i++) { // per curve segment
curr_offset++;
switch (tag[i]) {
case POTRACE_CORNER: {
// 0 => unused; 1 => vertex; 2 => endpoint
leftHandles.append(float3(control_points[i][1].x, control_points[i][1].y, 0.0f));
rightHandles.append(float3(control_points[i][1].x, control_points[i][1].y, 0.0f));
positions.append(float3(control_points[i][2].x, control_points[i][2].y, 0.0f));
break;
}
case POTRACE_CURVETO: {
// 0 => u; 1 => v; 2 => endpoint
leftHandles.append(float3(control_points[i][0].x, control_points[i][0].y, 0.0f));
rightHandles.append(float3(control_points[i][1].x, control_points[i][1].y, 0.0f));
positions.append(float3(control_points[i][2].x, control_points[i][2].y, 0.0f));
break;
}
default:
break;
}
}
offsets.append(curr_offset);
path = path->next;
}
Curves *curves_id = bke::curves_new_nomain(positions.size(), offsets.size() - 1);
bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id->geometry);
curves.fill_curve_types(CURVE_TYPE_BEZIER);
curves.handle_types_left_for_write().fill(BEZIER_HANDLE_ALIGN);
curves.handle_types_right_for_write().fill(BEZIER_HANDLE_ALIGN);
curves.resolution_for_write().fill(resolution);
curves.cyclic_for_write().fill(true); // potrace curves are guaranteed cyclic
curves.offsets_for_write().last() = positions.size();
curves.positions_for_write().copy_from(positions);
curves.offsets_for_write().copy_from(offsets);
curves.handle_positions_left_for_write().copy_from(leftHandles);
curves.handle_positions_right_for_write().copy_from(rightHandles);
return curves_id;
}
/**
* Traces an image into a Curves object.
* \param turn_policy: Determines how to resolve ambiguities during decomposition of an image into paths.
* \param threshold: Greyscale cutoff used to determine which pixels should belong to the curve.
* \param resolution: Curve resolution.
* \param scale: Scale applied to Curves points.
*/
Curves *trace_image(Image *image,
const int turn_policy,
const float threshold,
const int resolution,
const float scale)
{
void *lock = nullptr;
ImBuf *ibuf = BKE_image_acquire_ibuf(image, nullptr, &lock);
potrace_bitmap_t *bm = ED_gpencil_trace_bitmap_new(ibuf->x, ibuf->y);
ED_gpencil_trace_image_to_bitmap(ibuf, bm, threshold);
potrace_param_t *param = potrace_param_default();
param->turdsize = 0;
param->turnpolicy = turn_policy;
potrace_state_t *st = potrace_trace(param, bm);
if (st == nullptr || st->status != POTRACE_STATUS_OK) {
ED_gpencil_trace_bitmap_free(bm);
if (st) {
potrace_state_free(st);
}
potrace_param_free(param);
BKE_image_release_ibuf(image, ibuf, lock);
return nullptr;
}
/* Centers the image */
float2 offset(ibuf->x / 2, ibuf->y / 2);
float corrected_scale = correct_potrace_scale(ibuf->x, ibuf->y, scale);
Curves *curves_id = curve_from_potrace(st, resolution);
bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id->geometry);
auto correct_scale = [&](MutableSpan<float3> mspan) {
for (float3 &pos : mspan) {
pos = float3(
(pos.x - offset.x) * corrected_scale, (pos.y - offset.y) * corrected_scale, 0.0f);
}
};
correct_scale(curves.positions_for_write());
correct_scale(curves.handle_positions_left_for_write());
correct_scale(curves.handle_positions_right_for_write());
ED_gpencil_trace_bitmap_free(bm);
potrace_state_free(st);
potrace_param_free(param);
BKE_image_release_ibuf(image, ibuf, lock);
return curves_id;
}
} // namespace blender::geometry