void ColorPalette::draw_selected_color_value( void ) { const kvs::RGBColor current_color = this->color(); const int r = static_cast<int>( current_color.r() ); const int g = static_cast<int>( current_color.g() ); const int b = static_cast<int>( current_color.b() ); const float h = this->get_H_value(); const float s = this->get_S_value(); const float v = this->get_V_value(); char R[10]; sprintf( R, "R: %3d", r ); char G[10]; sprintf( G, "G: %3d", g ); char B[10]; sprintf( B, "B: %3d", b ); char H[10]; sprintf( H, "H: %3d", static_cast<int>( h * 255.0f + 0.5f ) ); char S[10]; sprintf( S, "S: %3d", static_cast<int>( s * 255.0f + 0.5f ) ); char V[10]; sprintf( V, "V: %3d", static_cast<int>( v * 255.0f + 0.5f ) ); int x = m_selected_color_box.x0(); int y = m_selected_color_box.y1() + 10; BaseClass::draw_text( x, y += BaseClass::characterHeight(), R ); BaseClass::draw_text( x, y += BaseClass::characterHeight(), G ); BaseClass::draw_text( x, y += BaseClass::characterHeight(), B ); BaseClass::draw_text( x, y += BaseClass::characterHeight(), "" ); BaseClass::draw_text( x, y += BaseClass::characterHeight(), H ); BaseClass::draw_text( x, y += BaseClass::characterHeight(), S ); BaseClass::draw_text( x, y += BaseClass::characterHeight(), V ); }
/*===========================================================================*/ void SphereGlyph::draw_element( const kvs::RGBColor& color, const kvs::UInt8 opacity ) { KVS_GL_CALL( glColor4ub( color.r(), color.g(), color.b(), opacity ) ); const GLdouble radius = 0.5; gluSphere( m_sphere, radius, static_cast<GLint>(m_nslices), static_cast<GLint>(m_nstacks) ); }
/*===========================================================================*/ void ColorMapPalette::mouseMoveEvent( kvs::MouseEvent* event ) { if ( !BaseClass::isShown() ) return; if ( BaseClass::isActive() ) { if ( m_palette.isActive() ) { // Color map palette geometry. const int x0 = m_palette.x0(); const int x1 = m_palette.x1(); const int y0 = m_palette.y0(); const int y1 = m_palette.y1(); // Current mouse cursor position. const int x = event->x(); const int y = event->y(); const int old_x = kvs::Math::Clamp( m_pressed_position.x(), x0, x1 ); const int old_y = kvs::Math::Clamp( m_pressed_position.y(), y0, y1 ); const int new_x = kvs::Math::Clamp( x, x0, x1 ); const int new_y = kvs::Math::Clamp( y, y0, y1 ); m_pressed_position.set( x, y ); const float old_ratio = static_cast<float>( y1 - old_y ) / ( y1 - y0 ); const float new_ratio = static_cast<float>( y1 - new_y ) / ( y1 - y0 ); const float diff_ratio = new_ratio - old_ratio; const float resolution = static_cast<float>( m_color_map.resolution() ); const int old_index = static_cast<int>( ( old_x - x0 ) * resolution / ( x1 - x0 ) + 0.5f ); const int new_index = static_cast<int>( ( new_x - x0 ) * resolution / ( x1 - x0 ) + 0.5f ); const float diff_index = static_cast<float>( new_index - old_index ); if ( m_color_palette ) m_drawing_color = m_color_palette->color(); const kvs::RGBColor drawing_color = m_drawing_color; const int begin_index = kvs::Math::Min( old_index, new_index ); const int end_index = kvs::Math::Max( old_index, new_index ); kvs::UInt8* data = const_cast<kvs::UInt8*>( m_color_map.table().data() ); kvs::UInt8* pdata = data + begin_index * 3; for ( int i = begin_index; i < end_index; i++, pdata += 3 ) { const float ratio = ( i - old_index ) * diff_ratio / diff_index + old_ratio; pdata[0] = static_cast<kvs::UInt8>( drawing_color.r() * ratio + pdata[0] * ( 1 - ratio ) ); pdata[1] = static_cast<kvs::UInt8>( drawing_color.g() * ratio + pdata[1] * ( 1 - ratio ) ); pdata[2] = static_cast<kvs::UInt8>( drawing_color.b() * ratio + pdata[2] * ( 1 - ratio ) ); } const size_t width = m_color_map.resolution(); m_texture.bind(); m_texture.load( width, data ); m_texture.unbind(); } BaseClass::screen()->redraw(); } }
/*===========================================================================*/ void SphereGlyph::attach_point( const kvs::PointObject* point ) { m_point = point; const size_t nvertices = point->numberOfVertices(); BaseClass::setCoords( point->coords() ); if ( BaseClass::directionMode() == BaseClass::DirectionByNormal ) { if ( point->numberOfNormals() != 0 ) { BaseClass::setDirections( point->normals() ); } } if ( point->numberOfSizes() == 1 ) { const kvs::Real32 size = point->size(); kvs::ValueArray<kvs::Real32> sizes( nvertices ); for ( size_t i = 0; i < nvertices; i++ ) sizes[i] = size; BaseClass::setSizes( sizes ); } else { BaseClass::setSizes( point->sizes() ); } if ( point->numberOfColors() == 1 ) { const kvs::RGBColor color = point->color(); kvs::ValueArray<kvs::UInt8> colors( nvertices * 3 ); for ( size_t i = 0, j = 0; i < nvertices; i++, j += 3 ) { colors[j] = color.r(); colors[j+1] = color.g(); colors[j+2] = color.b(); } BaseClass::setColors( colors ); } else { BaseClass::setColors( point->colors() ); } const kvs::UInt8 opacity = static_cast<kvs::UInt8>( 255 ); kvs::ValueArray<kvs::UInt8> opacities( nvertices ); for ( size_t i = 0; i < nvertices; i++ ) opacities[i] = opacity; BaseClass::setOpacities( opacities ); }
/*===========================================================================*/ void ColorMapPalette::mousePressEvent( kvs::MouseEvent* event ) { if ( !BaseClass::isShown() ) return; if ( BaseClass::contains( event->x(), event->y() ) ) { BaseClass::screen()->disable(); BaseClass::activate(); if ( m_palette.contains( event->x(), event->y(), true ) ) { m_palette.activate(); // Color map palette geometry. const int x0 = m_palette.x0(); const int x1 = m_palette.x1(); const int y0 = m_palette.y0(); const int y1 = m_palette.y1(); // Current mouse cursor position. const int x = event->x(); const int y = event->y(); m_pressed_position.set( x, y ); const float resolution = static_cast<float>( m_color_map.resolution() ); const float ratio = static_cast<float>( y1 - y ) / ( y1 - y0 ); const int index = static_cast<int>( ( x - x0 ) * resolution / ( x1 - x0 ) + 0.5f ); // Update the color data. if ( m_color_palette ) m_drawing_color = m_color_palette->color(); const kvs::RGBColor drawing_color = m_drawing_color; kvs::UInt8* data = const_cast<kvs::UInt8*>( m_color_map.table().data() ); kvs::UInt8* pdata = data; pdata = data + index * 3; pdata[0] = static_cast<kvs::UInt8>( drawing_color.r() * ratio + pdata[0] * ( 1 - ratio ) ); pdata[1] = static_cast<kvs::UInt8>( drawing_color.g() * ratio + pdata[1] * ( 1 - ratio ) ); pdata[2] = static_cast<kvs::UInt8>( drawing_color.b() * ratio + pdata[2] * ( 1 - ratio ) ); const size_t width = m_color_map.resolution(); m_texture.bind(); m_texture.load( width, data ); m_texture.unbind(); } BaseClass::screen()->redraw(); } }
kvs::ColorMap DivergingColorMap::Create( const kvs::RGBColor& rgb1, const kvs::RGBColor& rgb2, const size_t resolution ) { kvs::ColorMap::Table table( 3 * resolution ); kvs::UInt8* color = table.data(); for ( size_t i = 0; i < resolution; i++ ) { const kvs::Real32 ratio = kvs::Real32(i) / ( resolution - 1 ); const kvs::RGBColor rgb = ::Interpolate( rgb1, rgb2, ratio ); *( color++ ) = rgb.r(); *( color++ ) = rgb.g(); *( color++ ) = rgb.b(); } return kvs::ColorMap( table ); }
void ColorPalette::draw_selected_color_box( void ) { const int x0 = m_selected_color_box.x0(); const int y0 = m_selected_color_box.y0(); const int x1 = m_selected_color_box.x1(); const int y1 = m_selected_color_box.y1(); const kvs::RGBColor current_color = this->color(); glBegin( GL_QUADS ); glColor3ub( current_color.r(), current_color.g(), current_color.b() ); glVertex2i( x1, y1 ); glVertex2i( x0, y1 ); glVertex2i( x0, y0 ); glVertex2i( x1, y0 ); glEnd(); // Draw border. ::DrawRectangle( m_selected_color_box, 1, m_upper_edge_color, m_lower_edge_color ); }
void ColorPalette::draw_selected_color_value() { const kvs::RGBColor current_color = this->color(); const int r = static_cast<int>( current_color.r() ); const int g = static_cast<int>( current_color.g() ); const int b = static_cast<int>( current_color.b() ); char R[10]; sprintf( R, "R: %3d", r ); char G[10]; sprintf( G, "G: %3d", g ); char B[10]; sprintf( B, "B: %3d", b ); int x = m_selected_color_box.x0(); int y = m_selected_color_box.y1() + 10; const float height = BaseClass::painter().fontMetrics().height(); const kvs::Font font = BaseClass::painter().font(); BaseClass::painter().font().setStyleToRegular(); BaseClass::painter().drawText( kvs::Vec2( x, y += height ), R ); BaseClass::painter().drawText( kvs::Vec2( x, y += height ), G ); BaseClass::painter().drawText( kvs::Vec2( x, y += height ), B ); BaseClass::painter().setFont( font ); }
/*===========================================================================*/ void ScatterPlotRenderer::exec( kvs::ObjectBase* object, kvs::Camera* camera, kvs::Light* light ) { kvs::IgnoreUnusedVariable( light ); kvs::TableObject* table = kvs::TableObject::DownCast( object ); if ( !m_has_point_color ) if ( table->numberOfColumns() < 3 ) m_has_point_color = true; BaseClass::startTimer(); glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT ); ::BeginDraw(); glDisable( GL_LIGHTING ); glEnable( GL_POINT_SMOOTH ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // X and Y values. const kvs::AnyValueArray& x_values = table->column(0); const kvs::AnyValueArray& y_values = table->column(1); const kvs::Real64 x_min_value = table->minValue(0); const kvs::Real64 x_max_value = table->maxValue(0); const kvs::Real64 y_min_value = table->minValue(1); const kvs::Real64 y_max_value = table->maxValue(1); const int x0 = m_left_margin; const int x1 = camera->windowWidth() - m_right_margin; const int y0 = m_top_margin; const int y1 = camera->windowHeight() - m_bottom_margin; // Draw background. if ( m_background_color.a() > 0.0f ) { const GLubyte r = static_cast<GLubyte>( m_background_color.r() ); const GLubyte g = static_cast<GLubyte>( m_background_color.g() ); const GLubyte b = static_cast<GLubyte>( m_background_color.b() ); const GLubyte a = static_cast<GLubyte>( m_background_color.a() * 255.0f ); glBegin( GL_QUADS ); glColor4ub( r, g, b, a ); glVertex2i( x0, y0 ); glVertex2i( x1, y0 ); glVertex2i( x1, y1 ); glVertex2i( x0, y1 ); glEnd(); } const kvs::UInt8 opacity = m_point_opacity; const kvs::Real32 size = m_point_size; if ( m_has_point_color ) { const kvs::RGBColor color = m_point_color; glPointSize( size ); glBegin( GL_POINTS ); glColor4ub( color.r(), color.g(), color.b(), opacity ); const kvs::Real64 x_ratio = kvs::Real64( x1 - x0 ) / ( x_max_value - x_min_value ); const kvs::Real64 y_ratio = kvs::Real64( y1 - y0 ) / ( y_max_value - y_min_value ); const size_t nrows = table->numberOfRows(); for ( size_t i = 0; i < nrows; i++ ) { if ( !table->insideRange( i ) ) continue; const kvs::Real64 x_value = x_values[i].to<kvs::Real64>(); const kvs::Real64 y_value = y_values[i].to<kvs::Real64>(); const double x = x0 + ( x_value - x_min_value ) * x_ratio; const double y = y1 - ( y_value - y_min_value ) * y_ratio; glVertex2d( x, y ); } glEnd(); } else { const float color_axis_min_value = static_cast<float>( table->minValue(2) ); const float color_axis_max_value = static_cast<float>( table->maxValue(2) ); const kvs::AnyValueArray& color_axis_values = table->column(2); m_color_map.setRange( color_axis_min_value, color_axis_max_value ); glPointSize( size ); glBegin( GL_POINTS ); const kvs::Real64 x_ratio = kvs::Real64( x1 - x0 ) / ( x_max_value - x_min_value ); const kvs::Real64 y_ratio = kvs::Real64( y1 - y0 ) / ( y_max_value - y_min_value ); const size_t nrows = table->numberOfRows(); for ( size_t i = 0; i < nrows; i++ ) { if ( !table->insideRange( i ) ) continue; const kvs::Real64 color_value = color_axis_values[i].to<kvs::Real64>(); const kvs::RGBColor color = m_color_map.at( static_cast<float>( color_value) ); glColor4ub( color.r(), color.g(), color.b(), opacity ); const kvs::Real64 x_value = x_values[i].to<kvs::Real64>(); const kvs::Real64 y_value = y_values[i].to<kvs::Real64>(); const double x = x0 + ( x_value - x_min_value ) * x_ratio; const double y = y1 - ( y_value - y_min_value ) * y_ratio; glVertex2d( x, y ); } glEnd(); } ::EndDraw(); glPopAttrib(); BaseClass::stopTimer(); }
/*===========================================================================*/ void ParallelCoordinatesRenderer::exec( kvs::ObjectBase* object, kvs::Camera* camera, kvs::Light* light ) { kvs::IgnoreUnusedVariable( light ); kvs::TableObject* table = kvs::TableObject::DownCast( object ); BaseClass::startTimer(); kvs::OpenGL::WithPushedAttrib attrib( GL_ALL_ATTRIB_BITS ); // Anti-aliasing. if ( m_enable_anti_aliasing ) { #if defined ( GL_MULTISAMPLE ) if ( m_enable_multisample_anti_aliasing ) { GLint buffers = 0; GLint samples = 0; kvs::OpenGL::GetIntegerv( GL_SAMPLE_BUFFERS, &buffers ); kvs::OpenGL::GetIntegerv( GL_SAMPLES, &samples ); if ( buffers > 0 && samples > 1 ) kvs::OpenGL::Enable( GL_MULTISAMPLE ); } else #endif { kvs::OpenGL::Enable( GL_LINE_SMOOTH ); KVS_GL_CALL( glHint( GL_LINE_SMOOTH_HINT, GL_NICEST ) ); } } kvs::OpenGL::Enable( GL_BLEND ); kvs::OpenGL::SetBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); ::BeginDraw(); const float color_axis_min_value = static_cast<float>( table->minValue( m_active_axis ) ); const float color_axis_max_value = static_cast<float>( table->maxValue( m_active_axis ) ); const kvs::AnyValueArray& color_axis_values = table->column( m_active_axis ); m_color_map.setRange( color_axis_min_value, color_axis_max_value ); const int x0 = m_left_margin; const int x1 = camera->windowWidth() - m_right_margin; const int y0 = m_top_margin; const int y1 = camera->windowHeight() - m_bottom_margin; const size_t nrows = table->column(0).size(); const size_t naxes = table->numberOfColumns(); const float stride = float( x1 - x0 ) / ( naxes - 1 ); for ( size_t i = 0; i < nrows; i++ ) { if ( !table->insideRange( i ) ) continue; KVS_GL_CALL( glLineWidth( m_line_width ) ); KVS_GL_CALL_BEG( glBegin( GL_LINE_STRIP ) ); const kvs::Real64 color_value = color_axis_values[i].to<kvs::Real64>(); const kvs::RGBColor color = m_color_map.at( static_cast<float>( color_value ) ); KVS_GL_CALL_VER( glColor4ub( color.r(), color.g(), color.b(), m_line_opacity ) ); for ( size_t j = 0; j < naxes; j++ ) { const kvs::Real64 min_value = table->minValue(j); const kvs::Real64 max_value = table->maxValue(j); const kvs::Real64 value = table->column(j)[i].to<kvs::Real64>(); const kvs::Real64 x = m_left_margin + stride * j; const kvs::Real64 y = y1 - ( y1 - y0 ) * ( value - min_value ) / ( max_value - min_value ); KVS_GL_CALL_VER( glVertex2d( x, y ) ); } KVS_GL_CALL_END( glEnd() ); } ::EndDraw(); BaseClass::stopTimer(); }
void ColorPalette::draw_SV_palette( void ) { const int x0 = m_SV_palette.x0(); const int y0 = m_SV_palette.y0(); const int x1 = m_SV_palette.x1(); const int y1 = m_SV_palette.y1(); const float h = this->get_H_value(); const kvs::RGBColor c0( kvs::HSVColor( h, 1, 1 ) ); // top-right const kvs::RGBColor c1( kvs::HSVColor( h, 0, 1 ) ); // top-left const kvs::RGBColor c2( kvs::HSVColor( h, 0, 0 ) ); // bottom-left const kvs::RGBColor c3( kvs::HSVColor( h, 1, 0 ) ); // bottom-right // Draw SV palette. glBegin( GL_QUADS ); glColor3ub( c0.r(), c0.g(), c0.b() ); glVertex2i( x1, y0 ); glColor3ub( c1.r(), c1.g(), c1.b() ); glVertex2i( x0, y0 ); glColor3ub( c2.r(), c2.g(), c2.b() ); glVertex2i( x0, y1 ); glColor3ub( c3.r(), c3.g(), c3.b() ); glVertex2i( x1, y1 ); glEnd(); // Draw the cross lines. { const int margin = 4; const float color = 1.0f; const int cursor_x0 = kvs::Math::Max( m_S_indicator - margin, m_SV_palette.x0() ); const int cursor_y0 = kvs::Math::Max( m_V_indicator - margin, m_SV_palette.y0() ); const int cursor_x1 = kvs::Math::Min( m_S_indicator + margin, m_SV_palette.x1() ); const int cursor_y1 = kvs::Math::Min( m_V_indicator + margin, m_SV_palette.y1() ); glLineWidth( 1 ); glBegin( GL_LINES ); glColor3f( color, color, color ); glVertex2i( cursor_x0, cursor_y0 ); glVertex2i( cursor_x1, cursor_y0 ); // top glVertex2i( cursor_x0, cursor_y1 ); glVertex2i( cursor_x1, cursor_y1 ); // bottom glVertex2i( cursor_x0, cursor_y0 ); glVertex2i( cursor_x0, cursor_y1 + 1 ); // left glVertex2i( cursor_x1, cursor_y0 ); glVertex2i( cursor_x1, cursor_y1 + 1 ); // right glEnd(); glLineWidth( 1 ); glBegin( GL_LINES ); glColor3f( color, color, color ); // Horizontal lines. glVertex2i( x0, m_V_indicator ); glVertex2i( cursor_x0, m_V_indicator ); glVertex2i( cursor_x1, m_V_indicator ); glVertex2i( x1, m_V_indicator ); // Vertical lines. glVertex2i( m_S_indicator, y0 ); glVertex2i( m_S_indicator, cursor_y0 ); glVertex2i( m_S_indicator, cursor_y1 ); glVertex2i( m_S_indicator, y1 ); glEnd(); } // Draw border. ::DrawRectangle( m_SV_palette, 1, m_upper_edge_color, m_lower_edge_color ); }
/*===========================================================================*/ void PointObject::add( const PointObject& other ) { if ( this->coords().size() == 0 ) { // Copy the object. BaseClass::setCoords( other.coords() ); BaseClass::setNormals( other.normals() ); BaseClass::setColors( other.colors() ); this->setSizes( other.sizes() ); BaseClass::setMinMaxObjectCoords( other.minObjectCoord(), other.maxObjectCoord() ); BaseClass::setMinMaxExternalCoords( other.minExternalCoord(), other.maxExternalCoord() ); } else { if ( !BaseClass::hasMinMaxObjectCoords() ) { BaseClass::updateMinMaxCoords(); } kvs::Vec3 min_object_coord( BaseClass::minObjectCoord() ); kvs::Vec3 max_object_coord( BaseClass::maxObjectCoord() ); min_object_coord.x() = kvs::Math::Min( min_object_coord.x(), other.minObjectCoord().x() ); min_object_coord.y() = kvs::Math::Min( min_object_coord.y(), other.minObjectCoord().y() ); min_object_coord.z() = kvs::Math::Min( min_object_coord.z(), other.minObjectCoord().z() ); max_object_coord.x() = kvs::Math::Max( max_object_coord.x(), other.maxObjectCoord().x() ); max_object_coord.y() = kvs::Math::Max( max_object_coord.y(), other.maxObjectCoord().y() ); max_object_coord.z() = kvs::Math::Max( max_object_coord.z(), other.maxObjectCoord().z() ); BaseClass::setMinMaxObjectCoords( min_object_coord, max_object_coord ); BaseClass::setMinMaxExternalCoords( min_object_coord, max_object_coord ); // Integrate the coordinate values. kvs::ValueArray<kvs::Real32> coords; const size_t ncoords = this->coords().size() + other.coords().size(); coords.allocate( ncoords ); kvs::Real32* pcoords = coords.data(); // x,y,z, ... + x,y,z, ... = x,y,z, ... ,x,y,z, ... memcpy( pcoords, this->coords().data(), this->coords().byteSize() ); memcpy( pcoords + this->coords().size(), other.coords().data(), other.coords().byteSize() ); BaseClass::setCoords( coords ); // Integrate the normal vectors. kvs::ValueArray<kvs::Real32> normals; if ( this->normals().size() > 0 ) { if ( other.normals().size() > 0 ) { // nx,ny,nz, ... + nx,ny,nz, ... = nx,ny,nz, ... ,nx,ny,nz, ... const size_t nnormals = this->normals().size() + other.normals().size(); normals.allocate( nnormals ); kvs::Real32* pnormals = normals.data(); memcpy( pnormals, this->normals().data(), this->normals().byteSize() ); memcpy( pnormals + this->normals().size(), other.normals().data(), other.normals().byteSize() ); } else { // nx,ny,nz, ... + (none) = nx,ny,nz, ... ,0,0,0, ... const size_t nnormals = this->normals().size() + other.coords().size(); normals.allocate( nnormals ); kvs::Real32* pnormals = normals.data(); memcpy( pnormals, this->normals().data(), this->normals().byteSize() ); memset( pnormals + this->normals().size(), 0, other.coords().byteSize() ); } } else { if ( other.normals().size() > 0 ) { const size_t nnormals = this->coords().size() + other.normals().size(); normals.allocate( nnormals ); kvs::Real32* pnormals = normals.data(); // (none) + nx,ny,nz, ... = 0,0,0, ... ,nz,ny,nz, ... memset( pnormals, 0, this->coords().byteSize() ); memcpy( pnormals + this->coords().size(), other.normals().data(), other.normals().byteSize() ); } } BaseClass::setNormals( normals ); // Integrate the color values. kvs::ValueArray<kvs::UInt8> colors; if ( this->colors().size() > 1 ) { if ( other.colors().size() > 1 ) { // r,g,b, ... + r,g,b, ... = r,g,b, ... ,r,g,b, ... const size_t ncolors = this->colors().size() + other.colors().size(); colors.allocate( ncolors ); kvs::UInt8* pcolors = colors.data(); memcpy( pcolors, this->colors().data(), this->colors().byteSize() ); memcpy( pcolors + this->colors().size(), other.colors().data(), other.colors().byteSize() ); } else { // r,g,b, ... + R,G,B = r,g,b, ... ,R,G,B, ... ,R,G,B const size_t ncolors = this->colors().size() + other.coords().size(); colors.allocate( ncolors ); kvs::UInt8* pcolors = colors.data(); memcpy( pcolors, this->colors().data(), this->colors().byteSize() ); pcolors += this->colors().size(); const kvs::RGBColor color = other.color(); for ( size_t i = 0; i < other.coords().size(); i += 3 ) { *(pcolors++) = color.r(); *(pcolors++) = color.g(); *(pcolors++) = color.b(); } } } else { if ( other.colors().size() > 1 ) { // R,G,B + r,g,b, ... = R,G,B, ... ,R,G,B, r,g,b, ... const size_t ncolors = this->coords().size() + other.colors().size(); colors.allocate( ncolors ); kvs::UInt8* pcolors = colors.data(); const kvs::RGBColor color = this->color(); for ( size_t i = 0; i < this->coords().size(); i += 3 ) { *(pcolors++) = color.r(); *(pcolors++) = color.g(); *(pcolors++) = color.b(); } memcpy( pcolors, other.colors().data(), other.colors().byteSize() ); } else { const kvs::RGBColor color1 = this->color(); const kvs::RGBColor color2 = other.color(); if ( color1 == color2 ) { // R,G,B + R,G,B = R,G,B const size_t ncolors = 3; colors.allocate( ncolors ); kvs::UInt8* pcolors = colors.data(); *(pcolors++) = color1.r(); *(pcolors++) = color1.g(); *(pcolors++) = color1.b(); } else { // R,G,B + R,G,B = R,G,B, ... ,R,G,B, ... const size_t ncolors = this->coords().size() + other.coords().size(); colors.allocate( ncolors ); kvs::UInt8* pcolors = colors.data(); for ( size_t i = 0; i < this->coords().size(); i += 3 ) { *(pcolors++) = color1.r(); *(pcolors++) = color1.g(); *(pcolors++) = color1.b(); } for ( size_t i = 0; i < other.coords().size(); i += 3 ) { *(pcolors++) = color2.r(); *(pcolors++) = color2.g(); *(pcolors++) = color2.b(); } } } } BaseClass::setColors( colors ); // Integrate the size values. kvs::ValueArray<kvs::Real32> sizes; if ( this->sizes().size() > 1 ) { if ( other.sizes().size() > 1 ) { // s, ... + s, ... = s, ... ,s, ... const size_t nsizes = this->sizes().size() + other.sizes().size(); sizes.allocate( nsizes ); kvs::Real32* psizes = sizes.data(); memcpy( psizes, this->sizes().data(), this->sizes().byteSize() ); memcpy( psizes + this->sizes().size(), other.sizes().data(), other.sizes().byteSize() ); } else { // s, ... + S = s, ... ,S, ... ,S const size_t nsizes = this->sizes().size() + other.coords().size(); sizes.allocate( nsizes ); kvs::Real32* psizes = sizes.data(); memcpy( psizes, this->sizes().data(), this->sizes().byteSize() ); psizes += this->colors().size(); const kvs::Real32 size = other.size(); for ( size_t i = 0; i < other.coords().size(); i++ ) { *(psizes++) = size; } } } else { if ( other.sizes().size() > 1 ) { // S + s, ... = S, ... ,S, s, ... const size_t nsizes = this->coords().size() + other.sizes().size(); sizes.allocate( nsizes ); kvs::Real32* psizes = sizes.data(); const kvs::Real32 size = this->size(); for ( size_t i = 0; i < this->coords().size(); i++ ) { *(psizes++) = size; } memcpy( psizes, other.sizes().data(), other.sizes().byteSize() ); } else { const kvs::Real32 size1 = this->size(); const kvs::Real32 size2 = other.size(); if ( size1 == size2 ) { // S + S = S const size_t nsizes = 1; sizes.allocate( nsizes ); kvs::Real32* psizes = sizes.data(); *(psizes++) = size1; } else { // S + S = S, ... , S, ... const size_t nsizes = this->coords().size() + other.coords().size(); sizes.allocate( nsizes ); kvs::Real32* psizes = sizes.data(); for ( size_t i = 0; i < this->coords().size(); i++ ) { *(psizes++) = size1; } for ( size_t i = 0; i < other.coords().size(); i++ ) { *(psizes++) = size2; } } } } this->setSizes( sizes ); } }