void CEditInfo::saveReference()
{
if ( m_ref_parent_set.empty() )
return;
TiXmlNode* ref_root_node = m_xml_doc.FirstChild(REF_ROOT_NODE);
if ( !ref_root_node )
ref_root_node = m_xml_doc.InsertEndChild(TiXmlElement(REF_ROOT_NODE));
// get existed reference info, used to check multiple reference.
ReferenceSet exist_ref_set;
TiXmlElement* cur_ref_elem = ref_root_node->FirstChildElement(REF_ELEMENT_NODE);
while ( cur_ref_elem != 0 )
{
exist_ref_set.insert(cur_ref_elem->GetText());
cur_ref_elem = cur_ref_elem->NextSiblingElement();
}
// add reference info and check multiple reference.
ReferenceSet::iterator ref_iter = m_ref_parent_set.begin();
for ( ; ref_iter != m_ref_parent_set.end(); ++ref_iter )
{
string ref_parent = *ref_iter;
if ( exist_ref_set.find(ref_parent) != exist_ref_set.end() )
continue;
TiXmlElement ref_element(REF_ELEMENT_NODE);
TiXmlText ref_text(ref_parent);
ref_element.InsertEndChild(ref_text);
ref_root_node->InsertEndChild(ref_element);
}
}
void MapView::save(QXmlStreamWriter& xml, const QLatin1String& element_name) const
{
XmlElementWriter mapview_element(xml, element_name);
mapview_element.writeAttribute(literal::zoom, zoom);
mapview_element.writeAttribute(literal::rotation, rotation);
mapview_element.writeAttribute(literal::position_x, center_pos.nativeX());
mapview_element.writeAttribute(literal::position_y, center_pos.nativeY());
mapview_element.writeAttribute(literal::grid, grid_visible);
mapview_element.writeAttribute(literal::overprinting_simulation_enabled, overprinting_simulation_enabled);
{
XmlElementWriter map_element(xml, literal::map);
map_element.writeAttribute(literal::opacity, map_visibility->opacity);
map_element.writeAttribute(literal::visible, map_visibility->visible);
}
{
XmlElementWriter templates_element(xml, literal::templates);
templates_element.writeAttribute(literal::hidden, all_templates_hidden);
templates_element.writeAttribute(XmlStreamLiteral::count, template_visibilities.size());
for (auto it = template_visibilities.constBegin(), last = template_visibilities.constEnd(); it != last; ++it)
{
XmlElementWriter ref_element(xml, literal::ref);
ref_element.writeAttribute(literal::template_string, map->findTemplateIndex(it.key()));
ref_element.writeAttribute(literal::visible, (*it)->visible);
ref_element.writeAttribute(literal::opacity, (*it)->opacity);
}
}
}
inline void local_fft_r2c(float *x,
float *y,
float *w,
int N,
int stride,
int start)
{
int k;
if (N <= 2 || N % 2 != 0)
{
dft_r2c(x,
y,
w,
start,
stride,
N);
return;
}
float *S1 = y;
float *S2 = y + N;
local_fft_r2c(x,
S1,
w,
N/2,
stride*2,
start);
local_fft_r2c(x,
S2,
w,
N/2,
stride*2,
start + stride);
/*
** Expand based on conjugate symmetry
*/
int p;
for (k = N/2/2+1, p = (N/2+1)/2-1; k < N/2; k++, p--)
{
S1[2*k ] = S1[2*p ];
S1[2*k+1] = -S1[2*p+1];
S2[2*k ] = S2[2*p ];
S2[2*k+1] = -S2[2*p+1];
}
for (k = 0; k < N/2; k++)
{
float *w_ptr = ref_element(
w,
0,
stride,
k,
2);
float tmp[2];
tmp[0] = S1[2*k ] + (w_ptr[0]*S2[2*k ] - w_ptr[1]*S2[2*k+1]);
tmp[1] = S1[2*k+1] + (w_ptr[0]*S2[2*k+1] + w_ptr[1]*S2[2*k ]);
y[2*k ] = tmp[0];
y[2*k+1] = tmp[1];
}
// Nyquist
y[N] = y[N+1] = 0.0f;
for (k = 0; k < N; k++)
{
float *x_ptr = ref_element(
x,
start,
stride,
k,
1);
y[N] = x_ptr[0] - y[N];
}
y[N] = -y[N];
}
void MapView::load(QXmlStreamReader& xml)
{
XmlElementReader mapview_element(xml);
zoom = mapview_element.attribute<double>(literal::zoom);
if (zoom < 0.001)
zoom = 1.0;
rotation = mapview_element.attribute<double>(literal::rotation);
auto center_x = mapview_element.attribute<qint64>(literal::position_x);
auto center_y = mapview_element.attribute<qint64>(literal::position_y);
try
{
center_pos = MapCoord::fromNative64withOffset(center_x, center_y);
}
catch (std::range_error)
{
// leave center_pos unchanged
}
grid_visible = mapview_element.attribute<bool>(literal::grid);
overprinting_simulation_enabled = mapview_element.attribute<bool>(literal::overprinting_simulation_enabled);
updateTransform(CenterChange | ZoomChange | RotationChange);
while (xml.readNextStartElement())
{
if (xml.name() == literal::map)
{
XmlElementReader map_element(xml);
map_visibility->opacity = map_element.attribute<float>(literal::opacity);
if (map_element.hasAttribute(literal::visible))
map_visibility->visible = map_element.attribute<bool>(literal::visible);
else
map_visibility->visible = true;
}
else if (xml.name() == literal::templates)
{
XmlElementReader templates_element(xml);
int num_template_visibilities = templates_element.attribute<int>(XmlStreamLiteral::count);
if (num_template_visibilities > 0)
template_visibilities.reserve(qMin(num_template_visibilities, 20)); // 20 is not a limit
all_templates_hidden = templates_element.attribute<bool>(literal::hidden);
while (xml.readNextStartElement())
{
if (xml.name() == literal::ref)
{
XmlElementReader ref_element(xml);
int pos = ref_element.attribute<int>(literal::template_string);
if (pos >= 0 && pos < map->getNumTemplates())
{
TemplateVisibility* vis = getTemplateVisibility(map->getTemplate(pos));
vis->visible = ref_element.attribute<bool>(literal::visible);
vis->opacity = ref_element.attribute<float>(literal::opacity);
}
}
else
xml.skipCurrentElement();
}
}
else
xml.skipCurrentElement(); // unsupported
}
}
