Commit 62184d4d authored by Paul Asmuth's avatar Paul Asmuth
Browse files

improved color configuration

parent 8be03b76

common/config_helpers.cc

+8 −10
Original line number Diff line number Diff line
@@ -80,11 +80,12 @@ ReturnCode configure_color( 
  return ReturnCode::error("EARG", "invalid color");

}



ParserFn configure_color_var(Color* var) {

  return configure_var(

      static_cast<ScalarParseFn<Color>>(

          std::bind(&configure_color, std::placeholders::_1, std::placeholders::_2)),

      var);

ParserAtFn<Color> configure_color_fn() {

  return std::bind(&configure_color, std::placeholders::_1, std::placeholders::_2);

}



ParserFn configure_color_fn(Color* var) {

  return std::bind(&configure_color, std::placeholders::_1, var);

}



ReturnCode configure_float(
@@ -289,11 +290,8 @@ ReturnCode configure_series( 
  return ERROR_INVALID_ARGUMENT;

}



ParserFn configure_series_var(SeriesRef* series) {

  return configure_var(

      static_cast<ScalarParseFn<SeriesRef>>(

          std::bind(&configure_series, std::placeholders::_1, std::placeholders::_2)),

      series);

ParserFn configure_series_fn(SeriesRef* series) {

  return std::bind(&configure_series, std::placeholders::_1, series);

}



} // namespace plotfx

common/config_helpers.h

+14 −28
Original line number Diff line number Diff line
@@ -41,6 +41,9 @@ namespace plotfx { 


using ParserFn = std::function<ReturnCode (const plist::Property&)>;



template <typename T>

using ParserAtFn = std::function<ReturnCode (const plist::Property&, T*)>;



using ParserDefinitions = std::unordered_map<std::string, ParserFn>;



inline ReturnCode parseAll(
@@ -87,33 +90,20 @@ ReturnCode parse_classlike( 
    std::vector<std::string>* args);



template <typename T>

struct Slot {

  std::optional<DimensionConfig> dimension;

struct Variable {

  std::optional<T> constant;

  SeriesRef variable;

};



template <typename T>

ReturnCode resolve_slot(

    const Slot<T>& slot,

    std::function<ReturnCode (const DimensionConfig&, const Value&, T*)> map,

    const DataFrame& data,

    size_t data_idx,

    T* val);



template <typename T>

struct VariableSlot {

  std::string variable;

  std::vector<T> values;

};



template <typename T>

using ScalarParseFn = std::function<ReturnCode (const plist::Property&, T*)>;

std::vector<T> resolve(

    const Variable<T>& var,

    const DimensionMapFn<T>& map);



template <typename T>

using ListParseFn = std::function<ReturnCode (const plist::Property&, std::vector<T>*)>;



template <typename T>

ParserFn configure_slot(Slot<T>* slot);

ParserFn configure_var(

    Variable<T>* var,

    ParserAtFn<T> parser);



ParserFn configure_multiprop(const std::vector<ParserFn>& parsers);
@@ -129,7 +119,8 @@ ReturnCode configure_color( 
    const plist::Property& prop,

    Color* value);



ParserFn configure_color_var(Color* var);

ParserFn configure_color_fn(Color* var);

ParserAtFn<Color> configure_color_fn();



ReturnCode configure_float(

    const plist::Property& prop,
@@ -151,12 +142,7 @@ ReturnCode configure_series( 
    const plist::Property& prop,

    SeriesRef* data);



ParserFn configure_series_var(SeriesRef* data);



template <typename T>

ParserFn configure_var(

    ScalarParseFn<T> parser,

    T* value);

ParserFn configure_series_fn(SeriesRef* data);



} // namespace plotfx

common/config_helpers_impl.h

+22 −55
Original line number Diff line number Diff line
@@ -32,68 +32,35 @@ 
namespace plotfx {



template <typename T>

ReturnCode resolve_slot(

    const Slot<T>& slot,

    std::function<ReturnCode (const DimensionConfig&, const Value&, T*)> map,

    const DataFrame& data,

    size_t data_idx,

    T* val) {

  if (slot.constant) {

    *val = *slot.constant;

    return OK;

  }



  if (slot.dimension) {

    const auto& data_val = data_lookup(data, slot.dimension->key, data_idx);

    if (auto rc = map(*slot.dimension, data_val, val); !rc) {

ParserFn configure_var(

    Variable<T>* var,

    ParserAtFn<T> parser) {

  return [=] (const plist::Property& prop) -> ReturnCode {

    if (plist::is_enum(prop, "csv")) {

      return configure_series(prop, &var->variable);

    } else {

      T c;

      if (auto rc = parser(prop, &c); !rc) {

        return rc;

      }



      var->constant = c;

      return OK;

    }



  return OK;

}



template <typename T>

ReturnCode configure_slot(

    const plist::Property& prop,

    Slot<T>* slot) {

  if (plist::is_value(prop) && prop.value.size() > 0 && prop.value[0] == '$') {

    DimensionConfig d;

    d.key = prop.value.substr(1);

    slot->dimension = d;

  }



  return OK;

}



template <typename T>

ParserFn configure_slot(Slot<T>* slot) {

  return [slot] (const plist::Property& prop) {

    return configure_slot(prop, slot);

  };

}



template <typename T>

ReturnCode configure_var(

    const plist::Property& prop,

    ScalarParseFn<T> parser,

    T* value) {

  if (auto rc = parser(prop, value); !rc) {

    return rc;

std::vector<T> resolve(

    const Variable<T>& var,

    const DimensionMapFn<T>& map) {

  if (var.constant) {

    return {*var.constant};

  } else if (var.variable) {

    return map(*var.variable);

  } else {

    return {};

  }



  return OK;

}



template <typename T>

ParserFn configure_var(

    ScalarParseFn<T> parser,

    T* value) {

  return [parser, value] (const plist::Property& prop) {

    return configure_var(prop, parser, value);

  };

}



} // namespace plotfx

common/dimension.cc

+11 −38
Original line number Diff line number Diff line
@@ -55,48 +55,21 @@ void dimension_add( 
  map->emplace(d.key, d);

}



DimensionMapFn<Color> dimension_map_color_continuous(

DimensionMapFn<Color> series_to_colors(

    const DomainConfig& domain_config,

    const ColorScheme& palette) {

  return [palette] (const auto& dimension, const auto& value, Color* color) {

    *color = palette.get(domain_translate(dimension.domain, value));

    return OK;

  };

}



DimensionMapFn<Color> dimension_map_color_discrete(

    const ColorScheme& palette) {

  return [palette] (const auto& dimension, const auto& value, Color* color) {

    auto idx =

        domain_translate(dimension.domain, value) *

        domain_cardinality(dimension.domain);



    *color = palette.get(idx);

    return OK;

  };

}

  return [=] (const Series& series) {

    auto domain = domain_config;

    domain_fit(series, &domain);



ReturnCode dimension_resolve(

    const DataFrame& data,

    DimensionConfig* dimension) {

  const DataColumn* column = nullptr;

  if (auto rc = column_find(data, dimension->key, &column); !rc) {

    return rc;

    std::vector<Color> colors;

    for (const auto& v : series) {

      auto value = domain_translate(domain, v) * domain_cardinality(domain);

      colors.emplace_back(palette.get(value));

    }



  domain_fit(column->data, &dimension->domain);

  return OK;

}



ReturnCode dimension_resolve_all(

    const DataFrame& data,

    DimensionMap* map) {

  for (auto& e : *map) {

    if (auto rc = dimension_resolve(data, &e.second); !rc) {

      return rc;

    }

  }



  return OK;

    return colors;

  };

}



} // namespace plotfx

common/dimension.h

+4 −15
Original line number Diff line number Diff line
@@ -42,11 +42,7 @@ struct DimensionConfig { 
using DimensionMap = std::unordered_map<std::string, DimensionConfig>;



template <typename T>

using DimensionMapFn = std::function<

    ReturnCode(

        const DimensionConfig& dimension,

        const Value& val_in,

        T* val_out)>;

using DimensionMapFn = std::function<std::vector<T> (const Series&)>;



const DimensionConfig* dimension_find(

    const DimensionMap& map,
@@ -56,16 +52,9 @@ void dimension_add( 
    DimensionMap* map,

    const std::string& key);



DimensionMapFn<Color> dimension_map_color_continuous(const ColorScheme& palette);

DimensionMapFn<Color> dimension_map_color_discrete(const ColorScheme& palette);



ReturnCode dimension_resolve(

    const DataFrame& data,

    DimensionConfig* dimension);



ReturnCode dimension_resolve_all(

    const DataFrame& data,

    DimensionMap* map);

DimensionMapFn<Color> series_to_colors(

    const DomainConfig& domain_config,

    const ColorScheme& palette);



} // namespace plotfx

CRA Git | Maintained and supported by SUSTech CRA and CCSE