lamino-filters/src/ufo-filter-3d-edf-writer.c

#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
#include <stdio.h>

#include "ufo-filter-3d-edf-writer.h"


/**
 * SECTION:ufo-filter-3d-edf-writer
 * @Short_description: Stores 3d buffer as an EDF file
 * @Title: 3d-edf-writer
 *
 * The writer node writes each incoming buffer as an EDF file to disk.
 * Each file is prefixed with #UfoFilter3DEdfWriter:prefix and written into
 * #UfoFilter3DEdfWriter:path.
 */

struct _UfoFilter3DEdfWriterPrivate {
    gchar *path;
    gchar *prefix;
};

GType ufo_filter_3d_edf_writer_get_type(void) G_GNUC_CONST;

/* Inherit from UFO_TYPE_FILTER */
G_DEFINE_TYPE(UfoFilter3DEdfWriter, ufo_filter_3d_edf_writer, UFO_TYPE_FILTER_SINK);

#define UFO_FILTER_3D_EDF_WRITER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UFO_TYPE_FILTER_3D_EDF_WRITER, UfoFilter3DEdfWriterPrivate))

enum {
    PROP_0,
    PROP_PATH,
    PROP_PREFIX,
    N_PROPERTIES
};

static GParamSpec * edfwriter3d_properties[N_PROPERTIES] = { NULL, };

static gboolean
filter_3d_edf_write_header(FILE * file, const guint32 xs, const guint32 ys, const guint32 zs)
{
    /*
       {
       ByteOrder = LowByteFirst;
       DataType = FloatValue;
       Dim_1 = 1024;
       Dim_2 = 1024;
       Dim_3 = 256;
       Size = 268435456;
       */

    const guint32 headsz = 512;
    gchar  * header  =  g_strnfill (headsz, ' ');

    sprintf(header, "{\nByteOrder = LowByteFirst;\nDataType = FloatValue;\nDim_1 = %i;\nDim_2 = %i;\nDim_3 = %i;\nSize = %li;\n",
            xs, ys, zs, xs*ys*zs*sizeof(float));

    header[510] = '}';
    header[511] = '\x0A';

    fwrite(header, sizeof(char), headsz, file);
    return TRUE;
}

static gboolean
filter_3d_edf_write_body(FILE * file, float * data, const guint32 sz)
{
    fwrite(data, sizeof(float), sz, file);
    return TRUE;
}

static void
ufo_filter_3d_edf_writer_consume (UfoFilterSink *self, UfoBuffer *input[], GError **error)
{
    g_return_if_fail(UFO_IS_FILTER(self));
    UfoFilter3DEdfWriterPrivate *priv = UFO_FILTER_3D_EDF_WRITER_GET_PRIVATE(self);
    g_message("ufo_filter_3d_edf_writer_process");

    cl_command_queue cmd_queue = ufo_filter_get_command_queue (UFO_FILTER (self));
    guint num_dims = 0;
    guint *dim_size = NULL;
    guint counter = 0;
    GString *filename = g_string_new("");

    ufo_buffer_get_dimensions(input[0], &num_dims, &dim_size);
    g_assert(num_dims == 3);

    const guint xs = dim_size[0];
    const guint ys = dim_size[1];
    const guint zs = dim_size[2];

    float *data = ufo_buffer_get_host_array(input[0], (cl_command_queue) cmd_queue);

    g_string_printf(filename, "%s/%s%05i.edf", priv->path, priv->prefix, counter++);
    //if (!filter_write_tiff(data, filename->str, width, height))
    //				            g_message("something went wrong")
    // write EDF header
    // write raw data
    // temporal saving unless 3d writer is not ready
    FILE * idfile = fopen(filename->str,"wb");

    if (!filter_3d_edf_write_header(idfile, xs, ys, zs))
        g_message("cannot write edf header");

    if (!filter_3d_edf_write_body(idfile, data, xs*ys*zs))
        g_message("cannot write data");

    fclose(idfile);

    g_string_free(filename, TRUE);
    g_free(dim_size);
}

static void 
ufo_filter_3d_edf_writer_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
    UfoFilter3DEdfWriter *filter = UFO_FILTER_3D_EDF_WRITER(object);

    switch (property_id) {
        case PROP_PATH:
            g_free(filter->priv->path);
            filter->priv->path = g_strdup(g_value_get_string(value));
            break;
        case PROP_PREFIX:
            g_free(filter->priv->prefix);
            filter->priv->prefix = g_strdup(g_value_get_string(value));
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}


static void
ufo_filter_3d_edf_writer_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
    UfoFilter3DEdfWriter *filter = UFO_FILTER_3D_EDF_WRITER(object);

    switch (property_id) {
        case PROP_PATH:
            g_value_set_string(value, filter->priv->path);
            break;
        case PROP_PREFIX:
            g_value_set_string(value, filter->priv->prefix);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}

static void
ufo_filter_3d_edf_writer_class_init(UfoFilter3DEdfWriterClass *klass)
{
    UfoFilterSinkClass *filter_class = UFO_FILTER_SINK_CLASS(klass);
    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

    gobject_class->set_property = ufo_filter_3d_edf_writer_set_property;
    gobject_class->get_property = ufo_filter_3d_edf_writer_get_property;
    filter_class->consume = ufo_filter_3d_edf_writer_consume;

    edfwriter3d_properties[PROP_PREFIX] =
        g_param_spec_string("prefix",
                "Filename prefix",
                "Prefix of output filename.",
                "",
                G_PARAM_READWRITE);

    edfwriter3d_properties[PROP_PATH] =
        g_param_spec_string("path",
                "File path",
                "Path where to store files.",
                ".",
                G_PARAM_READWRITE);

    g_object_class_install_property(gobject_class, PROP_PATH, edfwriter3d_properties[PROP_PATH]);
    g_object_class_install_property(gobject_class, PROP_PREFIX, edfwriter3d_properties[PROP_PREFIX]);

    g_type_class_add_private(gobject_class, sizeof(UfoFilter3DEdfWriterPrivate));
}

static void
ufo_filter_3d_edf_writer_init (UfoFilter3DEdfWriter *self)
{
    UfoInputParameter input_params[] = {{3, UFO_FILTER_INFINITE_INPUT}};

    self->priv = UFO_FILTER_3D_EDF_WRITER_GET_PRIVATE(self);
    self->priv->path = g_strdup(".");
    self->priv->prefix = NULL;

    ufo_filter_register_inputs (UFO_FILTER (self), 1, input_params);
}

G_MODULE_EXPORT
UfoFilter *ufo_filter_plugin_new(void)
{
    return g_object_new(UFO_TYPE_FILTER_3D_EDF_WRITER, NULL);
}