core.filter.median¶

Inputs¶

Name	Type	Title	Mandatory	Description
input	core.type.f64		True	None

Outputs¶

Name	Type	Title	Description
output	core.type.f64		None

Parameters¶

Name	Type	Title	Mandatory	Default value	Description
size	core.type.u32	Selection size	True	None	None

State variables¶

Name	Type	Description
counter	core.type.u32	None
inited	core.type.bool	None
median_index	core.type.u32	None
filled_in	core.type.bool	None
selection	core.type.dptr	None

Usage XML code snippet¶

core_filter_median snippet for FLOW configuration file¶

<f name="median" by_spec="core.filter.median">
    <in alias="input">some_block_1/output</in>
    <param alias="size">0.0</param>
</f>

Function’s artifacts¶

Declaration for core_filter_median
Implementation for core_filter_median
Set parameters code for core_filter_median
Header of core_filter_median
Specification of core_filter_median
Other
- Interface of core_filter_median

declaration.py¶

from fspeclib import *

Function(
    name='core.filter.median',
    title=LocalizedString(
        en='Median filter'
    ),
    parameters=[
        Parameter(
            name='size',
            title='Selection size',
            value_type='core.type.u32',
        )
    ],
    inputs=[
        Input(
            name='input',
            title='',
            value_type='core.type.f64'
        ),
    ],
    outputs=[
        Output(
            name='output',
            title='',
            value_type='core.type.f64'
        ),
    ],

    state=[
        Variable(
            name='counter',
            title='',
            value_type='core.type.u32'
        ),
        Variable(
            name='inited',
            title='',
            value_type='core.type.bool'
        ),
        Variable(
            name='median_index',
            title='',
            value_type='core.type.u32'
        ),
        Variable(
            name='filled_in',
            title='',
            value_type='core.type.bool'
        ),
        Variable(
            name='selection',
            title='',
            value_type='core.type.dptr'
        ),
    ],
)

core_filter_median_exec.c¶

#include "core_filter_median.h"

void core_filter_median_exec(
    const core_filter_median_inputs_t *i,
    core_filter_median_outputs_t *o,
    const core_filter_median_params_t *p,
    core_filter_median_state_t *state
)
{
//    if (!state->inited) {
//        state->selection = calloc(p->size, sizeof(i->input));
//        state->inited = TRUE;
//    }
//    core_type_f64_t *sel = state->selection;
//
//    sel[state->counter++] = i->input;
//
//    if (state->counter >= p->size) {
//        state->counter = 0;
//        state->filled_in = TRUE;
//    }
//
//    if (state->filled_in) {
//        for(uint32_t i = 0; i < p->size; i++) {
//
//        }
//    }
}

core_filter_median_set_params.c¶

#include "core_filter_median.h"
#include "conv.h"

#include <string.h>

#include "error.h"

fspec_rv_t core_filter_median_set_params(
    core_filter_median_params_t *params,
    const func_param_t *param_pairs,
    int initial_call
)
{
    // Get parameters
    core_filter_median_params_t p = *params;

    core_filter_median_params_flags_t flags;
    memset(&flags, 0, sizeof(flags));

    int violation_count = 0;
    conv_rv_t crv = conv_rv_ok;

    // Parse parameters
    for (int i = 0; param_pairs[i].alias != NULL; i++) {
        if (strcmp(param_pairs[i].alias, "size") == 0) {
            if ((crv = conv_str_uint32(param_pairs[i].value, &p.size)) == conv_rv_ok) {
                flags.changed_param_size = 1;
            }
        } else {
            error("failed unsupported parameter '%s'", param_pairs[i].alias);
            violation_count ++;
        }

        if (crv != conv_rv_ok) {
            error("Parameter '%s' format error (%s)", param_pairs[i].alias, param_pairs[i].value);
            violation_count++;
        }
    }

    if (initial_call) {
        // Check all mandatory parameters are set
        if (!flags.changed_param_size) {
            error("failed missed mandatory parameter 'size'");
            violation_count ++;
        }
    }

    if (violation_count > 0) {
        return fspec_rv_inval_param;
    }

    // Set parameters
    *params = p;

    return fspec_rv_ok;
}

core_filter_median.h¶

/**
 *  Automatically-generated file. Do not edit!
 */

#ifndef FSPEC_CORE_FILTER_MEDIAN_H
#define FSPEC_CORE_FILTER_MEDIAN_H

#include <stdint.h>
#include <eswb/types.h>

#include "function.h"

/* Include declaration of dependency types */
#include "core_type_bool.h"
#include "core_type_dptr.h"
#include "core_type_f64.h"
#include "core_type_u32.h"

/**
 * @brief Parameters of `core.filter.median` function
 */
typedef struct core_filter_median_params_{
    core_type_u32_t size;  /// Selection size
} core_filter_median_params_t;

/**
 * @brief Inputs of `core.filter.median` function
 */
typedef struct core_filter_median_inputs_ {
    core_type_f64_t input;  ///

} core_filter_median_inputs_t;

/**
 * @brief Outputs of `core.filter.median` function
 */
typedef struct core_filter_median_outputs_ {
    core_type_f64_t output; ///

} core_filter_median_outputs_t;

/**
 * @brief State variables of `core.filter.median` function
 */
typedef struct core_filter_median_state_ {
    core_type_u32_t counter;  ///
    core_type_bool_t inited;  ///
    core_type_u32_t median_index;  ///
    core_type_bool_t filled_in;  ///
    core_type_dptr_t selection;  ///
} core_filter_median_state_t;

/**
 * @brief Parameter flags of `core.filter.median` function
 */
typedef struct core_filter_median_params_flags_ {
    uint64_t changed_param_size:1;
} core_filter_median_params_flags_t;

typedef struct core_filter_median_eswb_descriptors_ {
    eswb_topic_descr_t in_input;
    eswb_topic_descr_t out_all;
} core_filter_median_eswb_descriptors_t;

typedef struct core_filter_median_interface_ {
    core_filter_median_inputs_t i;
    core_filter_median_outputs_t o;
    core_filter_median_params_t p;
    core_filter_median_state_t state;
    core_filter_median_eswb_descriptors_t eswb_descriptors;
} core_filter_median_interface_t;

fspec_rv_t core_filter_median_set_params(
    core_filter_median_params_t *params,
    const func_param_t *param_pairs,
    int initial_call
);

void core_filter_median_exec(
    const core_filter_median_inputs_t *i,
    core_filter_median_outputs_t *o,
    const core_filter_median_params_t *p,
    core_filter_median_state_t *state
);

#endif // FSPEC_CORE_FILTER_MEDIAN_H

core_filter_median_spec.c¶

/**
 *  Automatically-generated file. Do not edit!
 */

#include "core_filter_median.h"
#include <eswb/types.h>

static const param_spec_t param_size = {
    .name = "size",
    .default_value = "0.0",
    .annotation = "Selection size",
    .flags = 0
};

static const param_spec_t *params[2] = {
    &param_size,
    NULL
};

static const input_spec_t i_input = {
    .name = "input",
    .annotation = "",
    .flags = 0
};

static const input_spec_t *inputs[2] = {
    &i_input,
    NULL
};

static const output_spec_t o_output = {
    .name = "output",
    .annotation = "",
    .flags = 0
};

static const output_spec_t *outputs[2] = {
    &o_output,
    NULL
};

fspec_rv_t core_filter_median_call_init_inputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td
);

fspec_rv_t core_filter_median_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
);

void core_filter_median_call_exec(void *dh);

fspec_rv_t core_filter_median_call_set_params(void *dh, const func_param_t *param_pairs, int initial_call);

const function_spec_t atomic_core_filter_median_spec = {
    .name = "core.filter.median",
    .annotation = "Median filter",
    .inputs = inputs,
    .outputs = outputs,
    .params = params
};

const function_calls_t atomic_core_filter_median_calls = {
    .interface_handle_size = sizeof(core_filter_median_interface_t),
    .init = NULL,
    .init_inputs = core_filter_median_call_init_inputs,
    .init_outputs = core_filter_median_call_init_outputs,
    .pre_exec_init = NULL,
    .exec = core_filter_median_call_exec,
    .set_params = core_filter_median_call_set_params
};

const function_handler_t atomic_core_filter_median_handler = {
    .spec = &atomic_core_filter_median_spec,
    .calls = &atomic_core_filter_median_calls,
    .extension_handler = NULL
};

core_filter_median_interface.c¶

/**
 *  Automatically-generated file. Do not edit!
 */

#include "core_filter_median.h"

#include "error.h"
#include <eswb/api.h>
#include <eswb/topic_proclaiming_tree.h>
#include <eswb/errors.h>

int core_filter_median_interface_inputs_init(
    core_filter_median_interface_t *interface,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td
)
{
    eswb_rv_t rv;
    int errcnt_no_topic = 0;
    int errcnt_no_input = 0;
    const char *topic_path_in_input = fspec_find_path2connect(conn_spec,"input");

    // Connecting mandatory input "input"
    if (topic_path_in_input != NULL) {
        rv = eswb_connect_nested(mounting_td, topic_path_in_input, &interface->eswb_descriptors.in_input);
        if(rv != eswb_e_ok) {
            error("failed connect input \"input\" to topic \"%s\": %s", topic_path_in_input, eswb_strerror(rv));
            errcnt_no_topic++;
        }
    } else {
        error("mandatory input \"input\" is not speicifed");
        errcnt_no_input++;
    }

    if ((errcnt_no_input > 0) || (errcnt_no_topic > 0)) {
        if (errcnt_no_input > errcnt_no_topic) {
            return fspec_rv_no_input;
        } else {
            return fspec_rv_no_topic;
        }
    }
    return fspec_rv_ok;
}

fspec_rv_t core_filter_median_interface_inputs_update(core_filter_median_interface_t *interface)
{
    eswb_rv_t rv;

    rv = eswb_read(interface->eswb_descriptors.in_input, &interface->i.input);
    if(rv != eswb_e_ok) {
        /*FIXME nothing to do yet*/
    }

    return 0;
}

fspec_rv_t core_filter_median_interface_outputs_init(
    core_filter_median_interface_t *interface,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    TOPIC_TREE_CONTEXT_LOCAL_DEFINE(cntx, 2);
    core_filter_median_outputs_t out;
    eswb_rv_t rv;

    topic_proclaiming_tree_t *rt = usr_topic_set_struct(cntx, out, func_name);

    usr_topic_add_struct_child(cntx, rt, core_filter_median_outputs_t, output, "output", tt_double);
    rv = eswb_proclaim_tree(mounting_td, rt, cntx->t_num, &interface->eswb_descriptors.out_all);
    if (rv != eswb_e_ok) {
        return fspec_rv_publish_err;
    }

    return fspec_rv_ok;
}

fspec_rv_t core_filter_median_interface_outputs_update(core_filter_median_interface_t *interface)
{
    eswb_rv_t rv;

    rv = eswb_update_topic(interface->eswb_descriptors.out_all, &interface->o);
    if (rv != eswb_e_ok) {
        return 1;
    }

    return 0;
}

void core_filter_median_interface_update(core_filter_median_interface_t *interface)
{
    core_filter_median_interface_inputs_update(interface);
    core_filter_median_exec(&interface->i, &interface->o, &interface->p, &interface->state);
    core_filter_median_interface_outputs_update(interface);
}

fspec_rv_t core_filter_median_call_set_params(void *dh, const func_param_t *param_pairs, int initial_call)
{
    core_filter_median_interface_t *interface = (core_filter_median_interface_t*) dh;
    return core_filter_median_set_params(&interface->p, param_pairs, initial_call);
}

fspec_rv_t core_filter_median_call_init_inputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td
)
{
    core_filter_median_interface_t *interface = (core_filter_median_interface_t*) dh;
    return core_filter_median_interface_inputs_init(interface, conn_spec, mounting_td);
}

fspec_rv_t core_filter_median_call_init_outputs(
    void *dh,
    const func_conn_spec_t *conn_spec,
    eswb_topic_descr_t mounting_td,
    const char *func_name
)
{
    core_filter_median_interface_t *interface = (core_filter_median_interface_t*) dh;
    return core_filter_median_interface_outputs_init(interface, conn_spec, mounting_td, func_name);
}

void core_filter_median_call_exec(void *dh)
{
    core_filter_median_interface_t *interface = (core_filter_median_interface_t*) dh;
    core_filter_median_interface_update(interface);
}

← core.cont.quadrotor_mix core.filter.mvng_av →