void
manager::event_tuple_send(const db::node *from, const db::node *to, const vm::tuple *tpl)
{
DECLARE_JSON("tuple_send");
ADD_FIELD("from", (int)(from->get_id()));
ADD_FIELD("to", (int)(to->get_id()));
ADD_TUPLE_FIELD(tpl);
SEND_CURRENT_CLIENT();
}
void
manager::event_set_edge_label(const vm::node_val from, const vm::node_val to, const string& label)
{
DECLARE_JSON("set_edge_label");
ADD_FIELD("from", (int)from);
ADD_FIELD("to", (int)to);
ADD_FIELD("label", label);
SEND_CURRENT_CLIENT();
}
void
manager::event_set_color(const db::node *n, const int r, const int g, const int b)
{
DECLARE_JSON("set_color");
ADD_NODE_FIELD(n);
ADD_FIELD("r", r);
ADD_FIELD("g", g);
ADD_FIELD("b", b);
SEND_CURRENT_CLIENT();
}
int CMP4Tag::WriteAacTag(char *Filename)
{
char buf[512], *faac_id_string, *faac_copyright_string;
ID3_Tag id3Tag;
FILE *file;
if((file=fopen(Filename,"r"))==NULL)
{
char buf[25+MAX_PATH+1];
sprintf(buf,"WriteAacTag: can't open \"%s\"",Filename);
MessageBox(NULL,buf,NULL,MB_OK);
return 1;
}
else
fclose(file);
id3Tag.Link(Filename);
sprintf(buf, "FAAC v%s", (faacEncGetVersion(&faac_id_string, &faac_copyright_string)==FAAC_CFG_VERSION) ? faac_id_string : " wrong libfaac version");
ADD_FIELD(id3Tag,ID3FID_ENCODEDBY,ID3FN_TEXT,buf);
ADD_FIELD(id3Tag,ID3FID_LEADARTIST,ID3FN_TEXT,artist);
ADD_FIELD(id3Tag,ID3FID_COMPOSER,ID3FN_TEXT,writer);
ADD_FIELD(id3Tag,ID3FID_TITLE,ID3FN_TEXT,title);
ADD_FIELD(id3Tag,ID3FID_ALBUM,ID3FN_TEXT,album);
sprintf(buf,"%d",trackno);
ADD_FIELD(id3Tag,ID3FID_TRACKNUM,ID3FN_TEXT,buf);
ADD_FIELD(id3Tag,ID3FID_YEAR,ID3FN_TEXT,year);
ADD_FIELD(id3Tag,ID3FID_CONTENTTYPE,ID3FN_TEXT,genre);
ADD_FIELD(id3Tag,ID3FID_COMMENT,ID3FN_TEXT,comment);
art.size=ReadCoverArtFile(artFilename,&art.data);
if(art.size)
{
ID3_Frame *NewFrame=new ID3_Frame(ID3FID_PICTURE);
char name[_MAX_FNAME], ext[_MAX_EXT];
_splitpath(artFilename,NULL,NULL,name,ext);
NewFrame->Field(ID3FN_DESCRIPTION)=name;
char buf[15];
sprintf(buf,"image/%s",check_image_header(art.data)==2 ? "jpeg" : strlwr(ext+1));
NewFrame->Field(ID3FN_MIMETYPE)=buf;
// NewFrame->Field(ID3FN_IMAGEFORMAT)=;
NewFrame->Field(ID3FN_PICTURETYPE)=(DWORD)art.pictureType;
NewFrame->Field(ID3FN_DATA).Set((BYTE *)art.data,art.size);
id3Tag.AttachFrame(NewFrame);
}
// setup all our rendering parameters
id3Tag.SetUnsync(false);
id3Tag.SetExtendedHeader(true);
id3Tag.SetCompression(true);
id3Tag.SetPadding(true);
// write any changes to the file
id3Tag.Update();
FREE_ARRAY(art.data);
return 0;
}
static void
now_playing(sr_session_t *s,
sr_track_t *t)
{
struct sr_session_priv *priv = s->priv;
SoupMessage *message;
GString *data;
char *artist, *title;
char *album = NULL, *mbid = NULL;
/* haven't got the session yet? */
if (!priv->session_id)
return;
data = g_string_new(NULL);
g_string_append_printf(data, "s=%s", priv->session_id);
artist = soup_uri_encode(t->artist, EXTRA_URI_ENCODE_CHARS);
title = soup_uri_encode(t->title, EXTRA_URI_ENCODE_CHARS);
if (t->album)
album = soup_uri_encode(t->album, EXTRA_URI_ENCODE_CHARS);
if (t->mbid)
mbid = soup_uri_encode(t->mbid, EXTRA_URI_ENCODE_CHARS);
/* required fields */
g_string_append_printf(data, "&a=%s&t=%s", artist, title);
/* optional fields */
ADD_FIELD("b", "s", album);
ADD_FIELD("l", "i", t->length);
ADD_FIELD("n", "i", t->position);
ADD_FIELD("m", "s", mbid);
g_free(artist);
g_free(title);
g_free(album);
g_free(mbid);
message = soup_message_new("POST", priv->now_playing_url);
soup_message_set_request(message,
"application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE,
data->str,
data->len);
soup_session_queue_message(priv->soup,
message,
now_playing_cb,
s);
g_string_free(data, false); /* soup gets ownership */
}
void
manager::event_program(vm::program *pgrm)
{
DECLARE_JSON("program");
ADD_FIELD("program", pgrm->dump_json());
Array rules;
for(size_t i(0); i < pgrm->num_rules(); i++)
UI_ADD_ELEM(rules, pgrm->get_rule(i)->get_string());
ADD_FIELD("rules", rules);
SEND_CURRENT_CLIENT();
}
void
manager::event_database(db::database *db)
{
DECLARE_JSON("database");
ADD_FIELD("database", db->dump_json());
SEND_CURRENT_CLIENT();
}
void
manager::event_rule_applied(const db::node *who, const vm::rule *rule)
{
DECLARE_JSON("rule_applied");
ADD_NODE_FIELD(who);
ADD_FIELD("rule", (int)rule->get_id());
SEND_CURRENT_CLIENT();
}
void
manager::event_new_node(const db::node *node)
{
DECLARE_JSON("new_node");
ADD_NODE_FIELD(node);
ADD_FIELD("translated", (int)node->get_translated_id());
SEND_CURRENT_CLIENT();
}
void
manager::event_program_running(void)
{
client *cl((client*)pthread_getspecific(client_key));
DECLARE_JSON("program_running");
ADD_FIELD("running", cl->all->PROGRAM->get_name());
SEND_CURRENT_CLIENT();
}
void test_dyn_array2 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb1, sb1a, abi64, abs1a;
DDS_DynamicType s1, s1a, ai64, as1a;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dds, dda, ddas, dd2;
DDS_ReturnCode_t rc;
DDS_BoundSeq bounds;
unsigned i, j;
v_printf ("test_dyn_array2 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2a";
sb1a = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb1a != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
DDS_SEQ_INIT (bounds);
dds_seq_require (&bounds, 1);
DDS_SEQ_LENGTH (bounds) = 1;
DDS_SEQ_ITEM (bounds, 0) = 5;
abi64 = DDS_DynamicTypeBuilderFactory_create_array_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_INT_64_TYPE),
&bounds);
fail_unless (abi64 != NULL);
ai64 = DDS_DynamicTypeBuilder_build (abi64);
fail_unless (ai64 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abi64);
md->name = "i64";
md->index = md->id = 0;
md->type = ai64;
rc = DDS_DynamicTypeBuilder_add_member (sb1a, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb1a, md, "ch", 1, 1, DDS_CHAR_8_TYPE);
s1a = DDS_DynamicTypeBuilder_build (sb1a);
fail_unless (s1a != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb1a);
DDS_SEQ_ITEM (bounds, 0) = 7;
abs1a = DDS_DynamicTypeBuilderFactory_create_array_type (s1a, &bounds);
fail_unless (abs1a != NULL);
dds_seq_cleanup (&bounds);
as1a = DDS_DynamicTypeBuilder_build (abs1a);
fail_unless (as1a != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abs1a);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2";
sb1 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb1 != NULL);
ADD_FIELD (sb1, md, "c", 0, 0, DDS_CHAR_8_TYPE);
md->name = "str2";
md->index = md->id = 1;
md->type = as1a;
rc = DDS_DynamicTypeBuilder_add_member (sb1, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb1, md, "u16", 2, 2, DDS_UINT_16_TYPE);
s1 = DDS_DynamicTypeBuilder_build (sb1);
fail_unless (s1 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb1);
ts = DDS_DynamicTypeSupport_create_type_support (s1);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s1);
fail_unless (dd != NULL);
ddas = DDS_DynamicDataFactory_create_data (as1a);
fail_unless (ddas != NULL);
SET_FIELD (dd, 0, char8, 'A');
for (i = 0; i < 7; i++) {
dds = DDS_DynamicDataFactory_create_data (s1a);
fail_unless (dds != NULL);
dda = DDS_DynamicDataFactory_create_data (ai64);
fail_unless (dda != NULL);
for (j = 0; j < 5; j++) {
SET_FIELD (dda, j, int64, ((i + 6) * j) << i);
}
SET_FIELD (dds, 0, complex, dda);
DDS_DynamicDataFactory_delete_data (dda);
SET_FIELD (dds, 1, char8, i + 0x30);
SET_FIELD (ddas, i, complex, dds);
DDS_DynamicDataFactory_delete_data (dds);
}
SET_FIELD (dd, 1, complex, ddas);
DDS_DynamicDataFactory_delete_data (ddas);
SET_FIELD (dd, 2, uint16, 1366);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicTypeBuilderFactory_delete_type (s1);
DDS_DynamicTypeBuilderFactory_delete_type (as1a);
DDS_DynamicTypeBuilderFactory_delete_type (s1a);
DDS_DynamicTypeBuilderFactory_delete_type (ai64);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
static void rtsp_build_common (char *buffer, int *at, rtsp_client_t *client, rtsp_command_t *cmd)
{
int ret;
ADD_FIELD("CSeq: %u\r\n", client->next_cseq);
if (cmd && cmd->accept)
{
ADD_FIELD("Accept: %s\r\n", cmd->accept);
}
if (cmd && cmd->authorization)
{
ADD_FIELD("Authorization: %s\r\n", cmd->authorization);
}
if (cmd && cmd->session)
{
ADD_FIELD("Session: %s\r\n", cmd->session);
}
if (cmd && cmd->range)
{
ADD_FIELD("Range: %s\r\n", cmd->range);
}
if (cmd && cmd->scale != 0)
{
ADD_FIELD("Scale: %d\r\n", cmd->scale);
}
if (cmd && cmd->speed != 0)
{
ADD_FIELD("Speed: %d\r\n", cmd->speed);
}
if (cmd && cmd->transport)
{
ADD_FIELD("Transport: %s;ServiceGroup=%d\r\n", cmd->transport,
cmd->serviceGroupID);
}
if (cmd && cmd->x_RegionID)
{
ADD_FIELD("x-RegionID: %s\r\n", "2561");
}
if (cmd && cmd->x_Info)
{
ADD_FIELD("x-Info: %s\r\n", cmd->x_Info);
}
ADD_FIELD("User-Agent: %s\r\n", USER_AGENT);
}
void test_dyn_mutable2 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb2, stb, sstb;
DDS_DynamicType s2, st, sst;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dd2, dds;
DDS_ReturnCode_t rc;
DDS_StringSeq ss;
unsigned n;
char *strings [] = {
"Hi there", "blabla", "\0", NULL,
"got here", "not yet done", "", "num8",
"9", "10", "11", "12",
"13", "14", "15", "16",
"17", "18", "19", "done :)"
};
v_printf ("test_mutable2 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2m";
sb2 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb2 != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
ADD_FIELD (sb2, md, "u16", 0, 5, DDS_UINT_16_TYPE);
set_key_annotation (sb2, "u16");
stb = DDS_DynamicTypeBuilderFactory_create_string_type (DDS_UNBOUNDED_COLLECTION);
fail_unless (stb != NULL);
st = DDS_DynamicTypeBuilder_build (stb);
fail_unless (st != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (stb);
sstb = DDS_DynamicTypeBuilderFactory_create_sequence_type (st,
DDS_UNBOUNDED_COLLECTION);
fail_unless (sstb != NULL);
sst = DDS_DynamicTypeBuilder_build (sstb);
fail_unless (sst != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sstb);
md->name = "s";
md->index = 1;
md->id = 6;
md->type = sst;
rc = DDS_DynamicTypeBuilder_add_member (sb2, md);
fail_unless (rc == DDS_RETCODE_OK);
set_ext_annotation (sb2, "MUTABLE_EXTENSIBILITY");
s2 = DDS_DynamicTypeBuilder_build (sb2);
fail_unless (s2 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb2);
ts = DDS_DynamicTypeSupport_create_type_support (s2);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic data item for this type. */
DDS_SEQ_INIT (ss);
dds_seq_from_array (&ss, strings, sizeof (strings) / sizeof (char *));
for (n = 0; n <= DDS_SEQ_MAXIMUM (ss); n++) {
dd = DDS_DynamicDataFactory_create_data (s2);
fail_unless (dd != NULL);
SET_FIELD (dd, 5, uint16, n);
dds = DDS_DynamicDataFactory_create_data (sst);
fail_unless (dds != NULL);
DDS_SEQ_LENGTH (ss) = n;
rc = DDS_DynamicData_set_string_values (dds, 0, &ss);
fail_unless (rc == DDS_RETCODE_OK);
SET_FIELD (dd, 6, complex, dds);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dds);
if (n > 2) {
n += 3;
if (n == 18)
n++;
}
}
dds_seq_cleanup (&ss);
DDS_DynamicTypeBuilderFactory_delete_type (s2);
DDS_DynamicTypeBuilderFactory_delete_type (sst);
DDS_DynamicTypeBuilderFactory_delete_type (st);
DDS_DynamicTypeSupport_delete_type_support (ts);
set_key_annotation (NULL, NULL);
set_ext_annotation (NULL, NULL);
v_printf ("success!\r\n");
}
void
sr_session_submit(sr_session_t *s)
{
struct sr_session_priv *priv = s->priv;
SoupMessage *message;
int i = 0;
GString *data;
GList *c;
/* haven't got the session yet? */
if (!priv->session_id)
return;
g_mutex_lock(priv->queue_mutex);
if (g_queue_is_empty(priv->queue) || priv->submit_count) {
g_mutex_unlock(priv->queue_mutex);
return;
}
data = g_string_new(NULL);
g_string_append_printf(data, "s=%s", priv->session_id);
for (c = priv->queue->head; c; c = c->next) {
sr_track_t *t = c->data;
char *artist, *title;
char *album = NULL, *mbid = NULL;
artist = soup_uri_encode(t->artist, EXTRA_URI_ENCODE_CHARS);
title = soup_uri_encode(t->title, EXTRA_URI_ENCODE_CHARS);
if (t->album)
album = soup_uri_encode(t->album, EXTRA_URI_ENCODE_CHARS);
if (t->mbid)
mbid = soup_uri_encode(t->mbid, EXTRA_URI_ENCODE_CHARS);
/* required fields */
g_string_append_printf(data, "&a[%i]=%s&t[%i]=%s&i[%i]=%i&o[%i]=%c",
i, artist,
i, title,
i, t->timestamp,
i, t->source);
/* optional fields */
ADD_FIELD("r", "c", t->rating);
ADD_FIELD("l", "i", t->length);
ADD_FIELD("b", "s", album);
ADD_FIELD("n", "i", t->position);
ADD_FIELD("m", "s", mbid);
g_free(artist);
g_free(title);
g_free(album);
g_free(mbid);
if (++i >= 50)
break;
}
priv->submit_count = i;
g_mutex_unlock(priv->queue_mutex);
message = soup_message_new("POST", priv->submit_url);
soup_message_set_request(message,
"application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE,
data->str,
data->len);
soup_session_queue_message(priv->soup,
message,
scrobble_cb,
s);
g_string_free(data, false); /* soup gets ownership */
}
std::string Regs::GetCommandName(int index) {
static std::unordered_map<u32, std::string> map;
if (map.empty()) {
#define ADD_FIELD(name) \
map.insert({static_cast<u32>(PICA_REG_INDEX(name)), #name}); \
/* TODO: change to Regs::name when VS2015 and other compilers support it */ \
for (u32 i = PICA_REG_INDEX(name) + 1; i < PICA_REG_INDEX(name) + sizeof(Regs().name) / 4; ++i) \
map.insert({i, #name + std::string("+") + std::to_string(i-PICA_REG_INDEX(name))}); \
ADD_FIELD(trigger_irq);
ADD_FIELD(cull_mode);
ADD_FIELD(viewport_size_x);
ADD_FIELD(viewport_size_y);
ADD_FIELD(viewport_depth_range);
ADD_FIELD(viewport_depth_far_plane);
ADD_FIELD(viewport_corner);
ADD_FIELD(texture0_enable);
ADD_FIELD(texture0);
ADD_FIELD(texture0_format);
ADD_FIELD(texture1);
ADD_FIELD(texture1_format);
ADD_FIELD(texture2);
ADD_FIELD(texture2_format);
ADD_FIELD(tev_stage0);
ADD_FIELD(tev_stage1);
ADD_FIELD(tev_stage2);
ADD_FIELD(tev_stage3);
ADD_FIELD(tev_combiner_buffer_input);
ADD_FIELD(tev_stage4);
ADD_FIELD(tev_stage5);
ADD_FIELD(tev_combiner_buffer_color);
ADD_FIELD(output_merger);
ADD_FIELD(framebuffer);
ADD_FIELD(vertex_attributes);
ADD_FIELD(index_array);
ADD_FIELD(num_vertices);
ADD_FIELD(vertex_offset);
ADD_FIELD(trigger_draw);
ADD_FIELD(trigger_draw_indexed);
ADD_FIELD(vs_default_attributes_setup);
ADD_FIELD(command_buffer);
ADD_FIELD(triangle_topology);
ADD_FIELD(restart_primitive);
ADD_FIELD(gs.bool_uniforms);
ADD_FIELD(gs.int_uniforms);
ADD_FIELD(gs.main_offset);
ADD_FIELD(gs.input_register_map);
ADD_FIELD(gs.uniform_setup);
ADD_FIELD(gs.program);
ADD_FIELD(gs.swizzle_patterns);
ADD_FIELD(vs.bool_uniforms);
ADD_FIELD(vs.int_uniforms);
ADD_FIELD(vs.main_offset);
ADD_FIELD(vs.input_register_map);
ADD_FIELD(vs.uniform_setup);
ADD_FIELD(vs.program);
ADD_FIELD(vs.swizzle_patterns);
#undef ADD_FIELD
}
// Return empty string if no match is found
auto it = map.find(index);
if (it != map.end()) {
return it->second;
} else {
return std::string();
}
}
inline bool CGPX_Import::Add_Fields(CSG_MetaData *pNode, CSG_Shapes *pPoints)
{
if( pPoints->Get_Field_Count() == 0 )
{
ADD_FIELD("ele" , SG_DATATYPE_Double); // <ele> xsd:decimal (Höhe)
ADD_FIELD("time" , SG_DATATYPE_String); // <time> xsd:dateTime (Datum und Zeit)
ADD_FIELD("magvar" , SG_DATATYPE_Double); // <magvar> degreesType (lokale magn. Missweisung)
ADD_FIELD("geoidheight" , SG_DATATYPE_Double); // <geoidheight> xsd:decimal (Höhe bezogen auf Geoid)
ADD_FIELD("name" , SG_DATATYPE_String); // <name> xsd:string (Beschreibung)
ADD_FIELD("cmt" , SG_DATATYPE_String); // <cmt> xsd:string (Kommentar)
ADD_FIELD("desc" , SG_DATATYPE_String); // <desc> xsd:string (Elementbeschreibung)
ADD_FIELD("src" , SG_DATATYPE_String); // <src> xsd:string (Quelle)
ADD_FIELD("link" , SG_DATATYPE_String); // <link> linkType (Link)
ADD_FIELD("sym" , SG_DATATYPE_String); // <sym> xsd:string (Darstellungssymbol)
ADD_FIELD("type" , SG_DATATYPE_String); // <type> xsd:string (Klassifikation)
ADD_FIELD("fix" , SG_DATATYPE_Double); // <fix> fixType
ADD_FIELD("sat" , SG_DATATYPE_Int ); // <sat> xsd:nonNegativeInteger (Anzahl der empfangenen Satelliten)
ADD_FIELD("hdop" , SG_DATATYPE_Double); // <hdop> xsd:decimal (hDOP)
ADD_FIELD("vdop" , SG_DATATYPE_Double); // <vdop> xsd:decimal (vDOP)
ADD_FIELD("pdop" , SG_DATATYPE_Double); // <pdop> xsd:decimal (3D DOP)
ADD_FIELD("ageofdgpsdata" , SG_DATATYPE_Double); // <ageofdgpsdata> xsd:decimal (Letzter DGPS update)
ADD_FIELD("dgpsid" , SG_DATATYPE_Int ); // <dgpsid> dgpsStationType (DGPS ID)
if( m_bTime && pNode->Get_Child(SG_T("time")) )
{
pPoints->Add_Field(SG_T("dtime"), SG_DATATYPE_Double);
}
else
{
m_bTime = false;
}
}
return( pPoints->Get_Field_Count() > 0 );
}
static void sapi_webjames_register_variables(zval *track_vars_array)
{
char buf[BUF_SIZE + 1];
char *docroot;
buf[BUF_SIZE] = '\0';
ADD_STRING("SERVER_SOFTWARE", configuration.server);
ADD_STRING("SERVER_NAME", configuration.serverip);
ADD_FIELD("SERVER_PROTOCOL", protocol);
ADD_NUM("SERVER_PORT", port);
ADD_STRING("SERVER_ADMIN",configuration.webmaster);
ADD_STRING("GATEWAY_INTERFACE", "CGI/1.1");
docroot = __unixify(WG(conn)->homedir,0,NULL,1024,0);
if (docroot) ADD_STRING("DOCUMENT_ROOT", docroot);
ADD_FIELD("REQUEST_METHOD", methodstr);
ADD_FIELD("REQUEST_URI", requesturi);
ADD_STRING("PATH_TRANSLATED", SG(request_info).path_translated);
ADD_FIELD("SCRIPT_NAME", uri);
ADD_FIELD("PHP_SELF", uri);
ADD_FIELD("QUERY_STRING", args);
snprintf(buf, BUF_SIZE, "%d.%d.%d.%d", WG(conn)->ipaddr[0], WG(conn)->ipaddr[1], WG(conn)->ipaddr[2], WG(conn)->ipaddr[3]);
ADD_STRING("REMOTE_ADDR", buf);
if (WG(conn)->dnsstatus == DNS_OK) ADD_FIELD("REMOTE_HOST", host);
if ((WG(conn)->method == METHOD_POST) || (WG(conn)->method == METHOD_PUT)) {
ADD_NUM("CONTENT_LENGTH", bodysize);
ADD_FIELD("CONTENT_TYPE", type);
}
if ((WG(conn)->method == METHOD_PUT) || (WG(conn)->method == METHOD_DELETE)) ADD_FIELD("ENTITY_PATH", requesturi);
if (WG(conn)->pwd) {
ADD_STRING("AUTH_TYPE", "basic");
ADD_FIELD("REMOTE_USER", authorization);
}
ADD_FIELD("HTTP_COOKIE", cookie);
ADD_FIELD("HTTP_USER_AGENT", useragent);
ADD_FIELD("HTTP_REFERER", referer);
ADD_FIELD("HTTP_ACCEPT", accept);
ADD_FIELD("HTTP_ACCEPT_LANGUAGE", acceptlanguage);
ADD_FIELD("HTTP_ACCEPT_CHARSET", acceptcharset);
ADD_FIELD("HTTP_ACCEPT_ENCODING", acceptencoding);
}
//---------------------------------------------------------------//
void CTableInitializer::InitializeWriter()
{
ADD_FIELD(DDS::FIELD_STOCK_SYMBOL, STREAM_STRING_ID);
ADD_FIELD(DDS::FIELD_BID, STREAM_FLOAT_ID);
ADD_FIELD(DDS::FIELD_BID_DATE, STREAM_DATETIME_ID);
ADD_FIELD(DDS::FIELD_BID_EXCHANGE, STREAM_EXCHANGE_ID);
ADD_FIELD(DDS::FIELD_BID_SIZE, STREAM_INT_ID);
ADD_FIELD(DDS::FIELD_ASK, STREAM_FLOAT_ID);
ADD_FIELD(DDS::FIELD_ASK_DATE, STREAM_DATETIME_ID);
ADD_FIELD(DDS::FIELD_ASK_EXCHANGE, STREAM_EXCHANGE_ID);
ADD_FIELD(DDS::FIELD_ASK_SIZE, STREAM_INT_ID);
ADD_FIELD(DDS::FIELD_LAST, STREAM_FLOAT_ID);
ADD_FIELD(DDS::FIELD_LAST_DATE, STREAM_DATETIME_ID);
ADD_FIELD(DDS::FIELD_LAST_EXCHANGE, STREAM_EXCHANGE_ID);
ADD_FIELD(DDS::FIELD_LAST_SIZE, STREAM_INT_ID);
ADD_FIELD(DDS::FIELD_VOLUME, STREAM_INT_ID);
ADD_FIELD(DDS::FIELD_OPTION_SYMBOL, STREAM_64BYTE_STRING_ID);
ADD_FIELD(DDS::FIELD_FUTURE_SYMBOL, STREAM_STRING_ID);
ADD_FIELD(DDS::FIELD_FUTURE_ROOT_SYMBOL, STREAM_STRING_ID);
ADD_FIELD(DDS::FIELD_FUTURE_OPTION_SYMBOL, STREAM_64BYTE_STRING_ID);
ADD_FIELD(DDS::FIELD_OPEN_INTEREST, STREAM_INT_ID);
ADD_FIELD(DDS::FIELD_PRICE_HIGH, STREAM_FLOAT_ID);
ADD_FIELD(DDS::FIELD_PRICE_LOW, STREAM_FLOAT_ID);
ADD_FIELD(IVRMFields::FIELD_OPEN_PRICE, STREAM_FLOAT_ID);
ADD_FIELD(IVRMFields::FIELD_NET_CHANGE_1, STREAM_FLOAT_ID);
ADD_FIELD(IVRMFields::FIELD_PRICE_TICK, STREAM_INT_ID);
};
void test_dyn_mutable1 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb2, ostb;
DDS_DynamicType s2, ot, ost;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dd2, dds;
DDS_ReturnCode_t rc;
DDS_ByteSeq bseq;
unsigned char values [] = { 0x22, 0x33, 0x4f, 0x5e, 0x6d, 0x7c, 0x8b };
v_printf ("test_mutable1 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct1m";
sb2 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb2 != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
ADD_FIELD (sb2, md, "i16", 0, 99, DDS_INT_16_TYPE);
set_id_annotation (sb2, "i16", 20);
ADD_FIELD (sb2, md, "u32", 1, 2, DDS_UINT_32_TYPE);
set_key_annotation (sb2, "u32");
ADD_FIELD (sb2, md, "i32", 2, 100, DDS_INT_32_TYPE);
set_id_annotation (sb2, "i32", 50);
ADD_FIELD (sb2, md, "u16", 0, DDS_MEMBER_ID_INVALID, DDS_UINT_16_TYPE);
set_id_annotation (sb2, "u16", 10);
set_key_annotation (sb2, "u16");
ADD_FIELD (sb2, md, "u64", 5, 51, DDS_UINT_64_TYPE);
ADD_FIELD (sb2, md, "i64", 5, DDS_MEMBER_ID_INVALID, DDS_INT_64_TYPE);
ADD_FIELD (sb2, md, "fl", 6, 53, DDS_FLOAT_32_TYPE);
ADD_FIELD (sb2, md, "d", 7, 54, DDS_FLOAT_64_TYPE);
ADD_FIELD (sb2, md, "ch", 8, 55, DDS_CHAR_8_TYPE);
set_id_annotation (sb2, "ch", 5);
set_key_annotation (sb2, "ch");
set_id_annotation (sb2, "fl", 4);
ot = DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_BYTE_TYPE);
fail_unless (ot != NULL);
ostb = DDS_DynamicTypeBuilderFactory_create_sequence_type (ot,
DDS_UNBOUNDED_COLLECTION);
fail_unless (ostb != NULL);
ost = DDS_DynamicTypeBuilder_build (ostb);
fail_unless (ost != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (ostb);
md->name = "s";
md->index = 9;
md->id = 9;
md->type = ost;
rc = DDS_DynamicTypeBuilder_add_member (sb2, md);
fail_unless (rc == DDS_RETCODE_OK);
set_ext_annotation (sb2, "MUTABLE_EXTENSIBILITY");
s2 = DDS_DynamicTypeBuilder_build (sb2);
fail_unless (s2 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb2);
ts = DDS_DynamicTypeSupport_create_type_support (s2);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s2);
fail_unless (dd != NULL);
SET_FIELD (dd, 50, int32, -5);
SET_FIELD (dd, 10, uint16, 0xDEAD);
SET_FIELD (dd, 20, int16, INT16_MIN);
SET_FIELD (dd, 2, uint32, UINT32_MAX);
SET_FIELD (dd, 52, int64, 100);
SET_FIELD (dd, 4, float32, 0.5f);
SET_FIELD (dd, 54, float64, 100e-5);
SET_FIELD (dd, 5, char8, 'd');
SET_FIELD (dd, 51, uint64, 5010000);
dds = DDS_DynamicDataFactory_create_data (ost);
fail_unless (dds != NULL);
DDS_SEQ_INIT (bseq);
dds_seq_from_array (&bseq, values, sizeof (values));
rc = DDS_DynamicData_set_byte_values (dds, 0, &bseq);
dds_seq_cleanup (&bseq);
fail_unless (rc == DDS_RETCODE_OK);
SET_FIELD (dd, 9, complex, dds);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dds);
DDS_DynamicTypeBuilderFactory_delete_type (s2);
DDS_DynamicTypeBuilderFactory_delete_type (ost);
DDS_DynamicTypeSupport_delete_type_support (ts);
set_id_annotation (NULL, NULL, 0);
set_key_annotation (NULL, NULL);
set_ext_annotation (NULL, NULL);
v_printf ("success!\r\n");
}
void test_dyn_oseq (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb, oseqb;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicType s, oseq;
DDS_DynamicData dd, dda, dd2;
DDS_ReturnCode_t rc;
DDS_ByteSeq values;
unsigned i;
v_printf ("test_dyn_oseq - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct3";
sb = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
ADD_FIELD (sb, md, "anuint", 0, 0, DDS_UINT_32_TYPE);
oseqb = DDS_DynamicTypeBuilderFactory_create_sequence_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_BYTE_TYPE),
0);
fail_unless (oseqb != NULL);
oseq = DDS_DynamicTypeBuilder_build (oseqb);
fail_unless (oseq != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (oseqb);
md->name = "oseq";
md->index = md->id = 1;
md->type = oseq;
rc = DDS_DynamicTypeBuilder_add_member (sb, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb, md, "ch", 2, 2, DDS_CHAR_8_TYPE);
s = DDS_DynamicTypeBuilder_build (sb);
fail_unless (s != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb);
ts = DDS_DynamicTypeSupport_create_type_support (s);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s);
fail_unless (dd != NULL);
dda = DDS_DynamicDataFactory_create_data (oseq);
fail_unless (dda != NULL);
SET_FIELD (dd, 0, uint32, 1000);
DDS_SEQ_INIT (values);
rc = dds_seq_require (&values, 21);
fail_unless (rc == DDS_RETCODE_OK);
for (i = 0; i < 21; i++)
DDS_SEQ_ITEM (values, i) = i + '0';
rc = DDS_DynamicData_set_byte_values (dda, 0, &values);
fail_unless (rc == DDS_RETCODE_OK);
SET_FIELD (dd, 1, complex, dda);
SET_FIELD (dd, 2, char8, 'X');
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dda);
DDS_DynamicTypeBuilderFactory_delete_type (oseq);
DDS_DynamicTypeBuilderFactory_delete_type (s);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
static PyObject *
build_filter_spec(const lzma_filter *f)
{
PyObject *spec;
spec = PyDict_New();
if (spec == NULL)
return NULL;
#define ADD_FIELD(SOURCE, FIELD) \
do { \
_Py_IDENTIFIER(FIELD); \
if (spec_add_field(spec, &PyId_##FIELD, SOURCE->FIELD) == -1) \
goto error;\
} while (0)
ADD_FIELD(f, id);
switch (f->id) {
/* For LZMA1 filters, lzma_properties_{encode,decode}() only look at the
lc, lp, pb, and dict_size fields. For LZMA2 filters, only the
dict_size field is used. */
case LZMA_FILTER_LZMA1: {
lzma_options_lzma *options = f->options;
ADD_FIELD(options, lc);
ADD_FIELD(options, lp);
ADD_FIELD(options, pb);
ADD_FIELD(options, dict_size);
break;
}
case LZMA_FILTER_LZMA2: {
lzma_options_lzma *options = f->options;
ADD_FIELD(options, dict_size);
break;
}
case LZMA_FILTER_DELTA: {
lzma_options_delta *options = f->options;
ADD_FIELD(options, dist);
break;
}
case LZMA_FILTER_X86:
case LZMA_FILTER_POWERPC:
case LZMA_FILTER_IA64:
case LZMA_FILTER_ARM:
case LZMA_FILTER_ARMTHUMB:
case LZMA_FILTER_SPARC: {
lzma_options_bcj *options = f->options;
ADD_FIELD(options, start_offset);
break;
}
default:
PyErr_Format(PyExc_ValueError, "Invalid filter ID: %llu", f->id);
goto error;
}
#undef ADD_FIELD
return spec;
error:
Py_DECREF(spec);
return NULL;
}
void
manager::on_message(connection_ptr conn, message_ptr msg)
{
const string content(msg->get_payload());
Value ret;
cleanup(); // do some maintenance
if(read(content, ret) && is_obj(ret)) {
Object obj(ret.get_obj());
Value type(get_field_from_obj(obj, "msg"));
if(is_string(type)) {
const string& str(type.get_str());
if(str == "next") {
client *cl(get_client(conn));
cl->counter++;
} else if(str == "load_temp") {
Value filev(get_field_from_obj(obj, "file"));
string file(filev.get_str());
if(valid_temp_file(file)) {
client *cl(get_client(conn));
cl->done = false;
cl->counter = 0;
if(cl->th != NULL) {
delete cl->th;
cl->th = NULL;
}
boost::thread *th = new boost::thread(boost::bind(&ui::manager::start_file, this, file, cl, true));
cl->th = th;
}
} else if(str == "load" || str == "load_temp") {
Value filev(get_field_from_obj(obj, "file"));
string file(filev.get_str());
client *cl(get_client(conn));
cl->done = false;
cl->counter = 0;
if(cl->th != NULL) {
delete cl->th;
cl->th = NULL;
}
boost::thread *th = new boost::thread(boost::bind(&ui::manager::start_file, this, file, cl, false));
cl->th = th;
} else if(str == "jump") {
Value node(get_field_from_obj(obj, "steps"));
if(is_int(node)) {
const int steps(node.get_int());
client *cl(get_client(conn));
cl->counter += steps;
}
} else if(str == "get_node") {
Value node(get_field_from_obj(obj, "node"));
if(is_int(node)) {
db::node::node_id id((db::node::node_id)node.get_int());
DECLARE_JSON("node");
ADD_FIELD("node", (int)id);
ADD_FIELD("info", sched::serial_ui_local::dump_node(id));
SEND_JSON(conn);
}
} else if(str == "change_node") {
Value node(get_field_from_obj(obj, "node"));
if(is_int(node)) {
db::node::node_id id((db::node::node_id)node.get_int());
sched::serial_ui_local::change_node(id);
DECLARE_JSON("changed_node");
ADD_FIELD("node", (int)id);
SEND_JSON(conn);
}
} else if(str == "terminate") {
client* cl(get_client(conn));
cl->done = true;
} else {
cerr << "Message not recognized: " << str << endl;
}
}
}
}
static int
parse_row_json(pycbc_Bucket *bucket, pycbc_ViewResult *vres,
pycbc_MultiResult *mres, const lcb_RESPVIEWQUERY *resp)
{
PyObject *dd = PyDict_New();
PyObject *docid;
int is_ok, rv = 0;
if (resp->ndocid) {
rv = pycbc_tc_decode_key(bucket, resp->docid, resp->ndocid, &docid);
if (rv == -1) {
goto GT_DONE;
} else {
PyDict_SetItem(dd, pycbc_helpers.vkey_id, docid);
Py_XDECREF(docid);
}
}
#define ADD_FIELD(helpname, fbase) \
add_view_field(dd, pycbc_helpers.helpname, resp->fbase, resp->n##fbase)
is_ok = ADD_FIELD(vkey_key, key) == 0 &&
ADD_FIELD(vkey_value, value) == 0 &&
ADD_FIELD(vkey_geo, geometry) == 0;
#undef ADD_FIELD
if (!is_ok) {
rv = -1;
goto GT_DONE;
} else {
PyList_Append(vres->rows, dd);
}
if (resp->docresp) {
/* include_docs */
const lcb_RESPGET *rg = resp->docresp;
pycbc_ValueResult *docres = pycbc_valresult_new(bucket);
docres->key = docid;
Py_INCREF(docid);
docres->rc = rg->rc;
if (rg->rc == LCB_SUCCESS) {
docres->cas = rg->cas;
docres->flags = rg->itmflags;
rv = pycbc_tc_decode_value(
bucket, rg->value, rg->nvalue, rg->itmflags, &docres->value);
if (rv != 0) {
pycbc_multiresult_adderr(mres);
}
}
PyDict_SetItem(dd, pycbc_helpers.vkey_docresp, (PyObject*)docres);
Py_DECREF(docres);
}
GT_DONE:
Py_DECREF(dd);
return rv;
}
//---------------------------------------------------------
bool CLAS_Import::On_Execute(void)
{
CSG_Parameter_PointCloud_List *pPointsList;
bool bValidity;
CSG_Strings Files;
int RGBrange;
int cntInvalid = 0;
bValidity = Parameters("VALID")->asBool();
RGBrange = Parameters("RGB_RANGE")->asInt();
//-----------------------------------------------------
if( !Parameters("FILES")->asFilePath()->Get_FilePaths(Files) )
{
return( false );
}
//-----------------------------------------------------
pPointsList = Parameters("POINTS")->asPointCloudList();
pPointsList ->Del_Items();
for(int i=0; i<Files.Get_Count(); i++)
{
SG_UI_Msg_Add(CSG_String::Format(_TL("Parsing %s ... "), SG_File_Get_Name(Files[i], true).c_str()), true);
std::ifstream ifs;
ifs.open(Files[i].b_str(), std::ios::in | std::ios::binary);
if( !ifs )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open LAS file!")));
continue;
}
//-----------------------------------------------------
// Check if LAS version is supported
liblas::LASReader *pReader;
try {
pReader = new liblas::LASReader(ifs);
}
catch(std::exception &e) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("LAS header exception: %s"), e.what()));
ifs.close();
return( false );
}
catch(...) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unknown LAS header exception!")));
ifs.close();
return( false );
}
delete (pReader);
ifs.clear();
//-----------------------------------------------------
liblas::LASReader reader(ifs);
liblas::LASHeader const& header = reader.GetHeader();
//-----------------------------------------------------
int nFields, iField[VAR_Count];
CSG_PointCloud *pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(Files[i], false));
nFields = 3;
ADD_FIELD("T", VAR_T, _TL("gps-time") , SG_DATATYPE_Double); // SG_DATATYPE_Long
ADD_FIELD("i", VAR_i, _TL("intensity") , SG_DATATYPE_Float); // SG_DATATYPE_Word
ADD_FIELD("a", VAR_a, _TL("scan angle") , SG_DATATYPE_Float); // SG_DATATYPE_Byte
ADD_FIELD("r", VAR_r, _TL("number of the return") , SG_DATATYPE_Int);
ADD_FIELD("c", VAR_c, _TL("classification") , SG_DATATYPE_Int); // SG_DATATYPE_Byte
ADD_FIELD("u", VAR_u, _TL("user data") , SG_DATATYPE_Double); // SG_DATATYPE_Byte
ADD_FIELD("n", VAR_n, _TL("number of returns of given pulse") , SG_DATATYPE_Int);
ADD_FIELD("R", VAR_R, _TL("red channel color") , SG_DATATYPE_Int); // SG_DATATYPE_Word
ADD_FIELD("G", VAR_G, _TL("green channel color") , SG_DATATYPE_Int);
ADD_FIELD("B", VAR_B, _TL("blue channel color") , SG_DATATYPE_Int);
ADD_FIELD("e", VAR_e, _TL("edge of flight line flag") , SG_DATATYPE_Char);
ADD_FIELD("d", VAR_d, _TL("direction of scan flag") , SG_DATATYPE_Char);
ADD_FIELD("p", VAR_p, _TL("point source ID") , SG_DATATYPE_Int); // SG_DATATYPE_Word
ADD_FIELD("C", VAR_C, _TL("rgb color") , SG_DATATYPE_Int);
//-----------------------------------------------------
int iPoint = 0;
try {
while( reader.ReadNextPoint() )
{
if (iPoint % 100000)
SG_UI_Process_Set_Progress(iPoint, header.GetPointRecordsCount());
liblas::LASPoint const& point = reader.GetPoint();
if( bValidity )
{
if( !point.IsValid() )
{
cntInvalid++;
continue;
}
}
pPoints->Add_Point(point.GetX(), point.GetY(), point.GetZ());
if( iField[VAR_T] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_T], point.GetTime());
if( iField[VAR_i] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_i], point.GetIntensity());
if( iField[VAR_a] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_a], point.GetScanAngleRank());
if( iField[VAR_r] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_r], point.GetReturnNumber());
if( iField[VAR_c] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_c], point.GetClassification());
if( iField[VAR_u] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_u], point.GetUserData());
if( iField[VAR_n] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_n], point.GetNumberOfReturns());
if( iField[VAR_R] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_R], point.GetColor().GetRed());
if( iField[VAR_G] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_G], point.GetColor().GetGreen());
if( iField[VAR_B] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_B], point.GetColor().GetBlue());
if( iField[VAR_e] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_e], point.GetFlightLineEdge());
if( iField[VAR_d] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_d], point.GetScanDirection());
if( iField[VAR_p] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_p], point.GetPointSourceID());
if( iField[VAR_C] > 0 )
{
double r, g, b;
r = point.GetColor().GetRed();
g = point.GetColor().GetGreen();
b = point.GetColor().GetBlue();
if (RGBrange == 0) // 16 bit
{
r = r / 65535 * 255;
g = g / 65535 * 255;
b = b / 65535 * 255;
}
pPoints->Set_Value(iPoint, iField[VAR_C], SG_GET_RGB(r, g, b));
}
iPoint++;
}
}
catch(std::exception &e) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("LAS reader exception: %s"), e.what()));
ifs.close();
return( false );
}
catch(...) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unknown LAS reader exception!")));
ifs.close();
return( false );
}
ifs.close();
pPointsList->Add_Item(pPoints);
DataObject_Add(pPoints);
//-----------------------------------------------------
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("METRIC_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("DISPLAY_VALUE_AGGREGATE"))
{
sParms("DISPLAY_VALUE_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("METRIC_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
}
DataObject_Set_Parameters(pPoints, sParms);
SG_UI_Msg_Add(_TL("okay"), false);
}
//-----------------------------------------------------
if( bValidity && cntInvalid > 0 )
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: %d invalid points skipped!"), cntInvalid), true);
return( true );
}
