void manipulateVoxel( const util::fvector3 physCoord, boost::shared_ptr<ImageHolder> image ) {
util::ivector4 voxel = image->getISISImage()->getIndexFromPhysicalCoords( physCoord );
image->correctVoxelCoords<3>( voxel );
util::ivector4 start;
util::ivector4 end;
const size_t timestep = image->getImageProperties().voxelCoords[dim_time];
for( unsigned short i = 0; i < 3; i++ ) {
start[i] = voxel[i] - m_Radius;
end[i] = voxel[i] + m_Radius;
}
unsigned short radSquare = m_Radius * m_Radius;
util::Value<double> colorValue( m_Interface.colorEdit->value() );
for( short k = start[2] + 1; k < end[2]; k++ ) {
for( short j = start[1] + 1; j < end[1]; j++ ) {
for( short i = start[0] + 1; i < end[0]; i++ ) {
int x = voxel[0] - i;
int y = voxel[1] - j;
int z = voxel[2] - k;
if( x *x + y *y + z *z <= radSquare ) {
util::ivector4 finalVoxel( i, j, k );
image->correctVoxelCoords<3>( finalVoxel );
image->setTypedVoxel<TYPE>( finalVoxel[0], finalVoxel[1], finalVoxel[2], timestep, colorValue.as<TYPE>() );
}
}
}
}
m_ViewerCore->getUICore()->refreshUI();
}
void KHueSaturationSelector::drawPalette( QPixmap *pixmap )
{
int xSize = contentsRect().width(), ySize = contentsRect().height();
QImage image( QSize( xSize, ySize ), QImage::Format_RGB32 );
QColor col;
int h, s;
uint *p;
col.setHsv( hue(), saturation(), colorValue() );
int _h, _s, _v, _r, _g, _b;
col.getHsv( &_h, &_s, &_v );
col.getRgb( &_r, &_g, &_b );
for ( s = ySize-1; s >= 0; s-- )
{
p = ( uint * ) image.scanLine( ySize - s - 1 );
for( h = 0; h < xSize; h++ )
{
switch ( chooserMode() ) {
case ChooserClassic:
default:
col.setHsv( 359 * h / ( xSize - 1 ), 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ), 192 );
break;
case ChooserHue:
col.setHsv( _h, 255 * h / ( xSize - 1 ), 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
case ChooserSaturation:
col.setHsv( 359 * h / ( xSize - 1 ), _s, 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
case ChooserValue:
col.setHsv( 359 * h / ( xSize - 1 ), 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ), _v );
break;
case ChooserRed:
col.setRgb( _r, 255 * h / ( xSize - 1 ), 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
case ChooserGreen:
col.setRgb( 255 * h / ( xSize - 1 ), _g, 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
case ChooserBlue:
col.setRgb( 255 * s / ( ( ySize == 1 ) ? 1 : ySize - 1 ), 255 * h / ( xSize - 1 ), _b );
break;
}
*p = col.rgb();
p++;
}
}
/*
if ( pixmap->depth() <= 8 )
{
const QVector<QColor> standardPalette = kdeui_standardPalette();
KImageEffect::dither( image, standardPalette.data(), standardPalette.size() );
}
*/
*pixmap = QPixmap::fromImage( image );
}
static void apply_paint_color(const SkPaint& paint, Json::Value* target) {
SkColor color = paint.getColor();
if (color != SK_ColorBLACK) {
Json::Value colorValue(Json::arrayValue);
colorValue.append(Json::Value(SkColorGetA(color)));
colorValue.append(Json::Value(SkColorGetR(color)));
colorValue.append(Json::Value(SkColorGetG(color)));
colorValue.append(Json::Value(SkColorGetB(color)));
(*target)[SKJSONCANVAS_ATTRIBUTE_COLOR] = colorValue;;
}
}
void ColorPickerApp::mousePressEvent(QMouseEvent *event){
QGraphicsItem *item = m_graphicsView->itemAt(event->pos() - this->pos());
if (item == m_color0)
{
m_frameWidget->popApp();
emit inputFinished(0, colorValue(m_furnitureIndex, 0));
}
if (item == m_color1)
{
m_frameWidget->popApp();
emit inputFinished(1, colorValue(m_furnitureIndex, 1));
}
if (item == m_color2)
{
m_frameWidget->popApp();
emit inputFinished(2, colorValue(m_furnitureIndex, 2));
}
}
int symbolRank(CostSymbol symbol)
{
auto cv = colorValue(symbol.colors.colors());
if( cv > 0 ) return cv;
switch( symbol.specific ) {
case CostSymbol::snow: return 1000;
case CostSymbol::phyrexian: return 1001;
case CostSymbol::X:
case CostSymbol::Y:
case CostSymbol::Z:
return 10000;
default:
return 100 + symbol.generic;
}
}
// ============================ Main Loop =====================================
void loop() {
// While not in the halting state, update the state with the sensors
// then move according to state
int color = colorValue();
// If colliding, reposition
if(collide == true && state != HALT){
reposition();
}
// If not colliding, move according to state
else{
//checkstate();
move();
}
// Don't go forever
if (millis() > MAX_RUNTIME){
//state = HALT;
}
Serial.print("current state: ");Serial.println(state);
//delay(1000);
}
/* static */
bool
UsdMayaTranslatorMesh::_AssignColorSetPrimvarToMesh(
const UsdGeomMesh& primSchema,
const UsdGeomPrimvar& primvar,
MFnMesh& meshFn)
{
const TfToken& primvarName = primvar.GetPrimvarName();
const SdfValueTypeName& typeName = primvar.GetTypeName();
MString colorSetName(primvarName.GetText());
// If the primvar is displayOpacity and it is a FloatArray, check if
// displayColor is authored. If not, we'll import this 'displayOpacity'
// primvar as a 'displayColor' color set. This supports cases where the
// user created a single channel value for displayColor.
// Note that if BOTH displayColor and displayOpacity are authored, they will
// be imported as separate color sets. We do not attempt to combine them
// into a single color set.
if (primvarName == UsdMayaMeshColorSetTokens->DisplayOpacityColorSetName &&
typeName == SdfValueTypeNames->FloatArray) {
if (!UsdMayaRoundTripUtil::IsAttributeUserAuthored(primSchema.GetDisplayColorPrimvar())) {
colorSetName = UsdMayaMeshColorSetTokens->DisplayColorColorSetName.GetText();
}
}
// We'll need to convert colors from linear to display if this color set is
// for display colors.
const bool isDisplayColor =
(colorSetName == UsdMayaMeshColorSetTokens->DisplayColorColorSetName.GetText());
// Get the raw data before applying any indexing. We'll only populate one
// of these arrays based on the primvar's typeName, and we'll also set the
// color representation so we know which array to use later.
VtFloatArray alphaArray;
VtVec3fArray rgbArray;
VtVec4fArray rgbaArray;
MFnMesh::MColorRepresentation colorRep;
size_t numValues = 0;
MStatus status = MS::kSuccess;
if (typeName == SdfValueTypeNames->FloatArray) {
colorRep = MFnMesh::kAlpha;
if (!primvar.Get(&alphaArray) || alphaArray.empty()) {
status = MS::kFailure;
} else {
numValues = alphaArray.size();
}
} else if (typeName == SdfValueTypeNames->Float3Array ||
typeName == SdfValueTypeNames->Color3fArray) {
colorRep = MFnMesh::kRGB;
if (!primvar.Get(&rgbArray) || rgbArray.empty()) {
status = MS::kFailure;
} else {
numValues = rgbArray.size();
}
} else if (typeName == SdfValueTypeNames->Float4Array ||
typeName == SdfValueTypeNames->Color4fArray) {
colorRep = MFnMesh::kRGBA;
if (!primvar.Get(&rgbaArray) || rgbaArray.empty()) {
status = MS::kFailure;
} else {
numValues = rgbaArray.size();
}
} else {
TF_WARN("Unsupported color set primvar type '%s' for primvar '%s' on "
"mesh: %s",
typeName.GetAsToken().GetText(),
primvarName.GetText(),
primvar.GetAttr().GetPrimPath().GetText());
return false;
}
if (status != MS::kSuccess || numValues == 0) {
TF_WARN("Could not read color set values from primvar '%s' on mesh: %s",
primvarName.GetText(),
primvar.GetAttr().GetPrimPath().GetText());
return false;
}
VtIntArray assignmentIndices;
int unauthoredValuesIndex = -1;
if (primvar.GetIndices(&assignmentIndices)) {
// The primvar IS indexed, so the indices array is what determines the
// number of color values.
numValues = assignmentIndices.size();
unauthoredValuesIndex = primvar.GetUnauthoredValuesIndex();
}
// Go through the color data and translate the values into MColors in the
// colorArray, taking into consideration that indexed data may have been
// authored sparsely. If the assignmentIndices array is empty then the data
// is NOT indexed.
// Note that with indexed data, the data is added to the arrays in ascending
// component ID order according to the primvar's interpolation (ascending
// face ID for uniform interpolation, ascending vertex ID for vertex
// interpolation, etc.). This ordering may be different from the way the
// values are ordered in the primvar. Because of this, we recycle the
// assignmentIndices array as we go to store the new mapping from component
// index to color index.
MColorArray colorArray;
for (size_t i = 0; i < numValues; ++i) {
int valueIndex = i;
if (i < assignmentIndices.size()) {
// The data is indexed, so consult the indices array for the
// correct index into the data.
valueIndex = assignmentIndices[i];
if (valueIndex == unauthoredValuesIndex) {
// This component is unauthored, so just update the
// mapping in assignmentIndices and then skip the value.
// We don't actually use the value at the unassigned index.
assignmentIndices[i] = -1;
continue;
}
// We'll be appending a new value, so the current length of the
// array gives us the new value's index.
assignmentIndices[i] = colorArray.length();
}
GfVec4f colorValue(1.0);
switch(colorRep) {
case MFnMesh::kAlpha:
colorValue[3] = alphaArray[valueIndex];
break;
case MFnMesh::kRGB:
colorValue[0] = rgbArray[valueIndex][0];
colorValue[1] = rgbArray[valueIndex][1];
colorValue[2] = rgbArray[valueIndex][2];
break;
case MFnMesh::kRGBA:
colorValue[0] = rgbaArray[valueIndex][0];
colorValue[1] = rgbaArray[valueIndex][1];
colorValue[2] = rgbaArray[valueIndex][2];
colorValue[3] = rgbaArray[valueIndex][3];
break;
default:
break;
}
if (isDisplayColor) {
colorValue = UsdMayaColorSpace::ConvertLinearToMaya(colorValue);
}
MColor mColor(colorValue[0], colorValue[1], colorValue[2], colorValue[3]);
colorArray.append(mColor);
}
// colorArray now stores all of the values and any unassigned components
// have had their indices set to -1, so update the unauthored values index.
unauthoredValuesIndex = -1;
const bool clamped = UsdMayaRoundTripUtil::IsPrimvarClamped(primvar);
status = meshFn.createColorSet(colorSetName, nullptr, clamped, colorRep);
if (status != MS::kSuccess) {
TF_WARN("Unable to create color set '%s' for mesh: %s",
colorSetName.asChar(),
meshFn.fullPathName().asChar());
return false;
}
// Create colors on the mesh from the values we collected out of the
// primvar. We'll assign mesh components to these values below.
status = meshFn.setColors(colorArray, &colorSetName, colorRep);
if (status != MS::kSuccess) {
TF_WARN("Unable to set color data on color set '%s' for mesh: %s",
colorSetName.asChar(),
meshFn.fullPathName().asChar());
return false;
}
const TfToken& interpolation = primvar.GetInterpolation();
// Build an array of value assignments for each face vertex in the mesh.
// Any assignments left as -1 will not be assigned a value.
MIntArray colorIds = _GetMayaFaceVertexAssignmentIds(meshFn,
interpolation,
assignmentIndices,
unauthoredValuesIndex);
status = meshFn.assignColors(colorIds, &colorSetName);
if (status != MS::kSuccess) {
TF_WARN("Could not assign color values to color set '%s' on mesh: %s",
colorSetName.asChar(),
meshFn.fullPathName().asChar());
return false;
}
return true;
}
void KColorValueSelector::drawPalette( QPixmap *pixmap )
{
int xSize = contentsRect().width(), ySize = contentsRect().height();
QImage image( QSize( xSize, ySize ), QImage::Format_RGB32 );
QColor col;
uint *p;
QRgb rgb;
int _r, _g, _b;
col.setHsv( hue(), saturation(), colorValue() );
col.getRgb( &_r, &_g, &_b );
if ( orientation() == Qt::Horizontal )
{
for ( int v = 0; v < ySize; v++ )
{
p = ( uint * ) image.scanLine( ySize - v - 1 );
for( int x = 0; x < xSize; x++ )
{
switch ( chooserMode() ) {
case ChooserClassic:
default:
col.setHsv( hue(), saturation(), 255 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ) );
break;
case ChooserRed:
col.setRgb( 255 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ), _g, _b );
break;
case ChooserGreen:
col.setRgb( _r, 255 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ), _b );
break;
case ChooserBlue:
col.setRgb( _r, _g, 255 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ) );
break;
case ChooserHue:
col.setHsv( 360 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ), 255, 255 );
break;
case ChooserSaturation:
col.setHsv( hue(), 255 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ), colorValue() );
break;
case ChooserValue:
col.setHsv( hue(), saturation(), 255 * x / ( ( xSize == 1 ) ? 1 : xSize - 1 ) );
break;
}
rgb = col.rgb();
*p++ = rgb;
}
}
}
if( orientation() == Qt::Vertical )
{
for ( int v = 0; v < ySize; v++ )
{
p = ( uint * ) image.scanLine( ySize - v - 1 );
switch ( chooserMode() ) {
case ChooserClassic:
default:
col.setHsv( hue(), saturation(), 255 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
case ChooserRed:
col.setRgb( 255 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ), _g, _b );
break;
case ChooserGreen:
col.setRgb( _r, 255 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ), _b );
break;
case ChooserBlue:
col.setRgb( _r, _g, 255 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
case ChooserHue:
col.setHsv( 360 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ), 255, 255 );
break;
case ChooserSaturation:
col.setHsv( hue(), 255 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ), colorValue() );
break;
case ChooserValue:
col.setHsv( hue(), saturation(), 255 * v / ( ( ySize == 1 ) ? 1 : ySize - 1 ) );
break;
}
rgb = col.rgb();
for ( int i = 0; i < xSize; i++ )
*p++ = rgb;
}
}
/*
if ( pixmap->depth() <= 8 )
{
extern QVector<QColor> kdeui_standardPalette();
const QVector<QColor> standardPalette = kdeui_standardPalette();
KImageEffect::dither( image, standardPalette.data(), standardPalette.size() );
}
*/
*pixmap = QPixmap::fromImage( image );
}
// Updates the state of the machine according to the color sensor
void checkstate(){
switch (state){
case GO_UNTIL_COLLIDE:
//only transitions out via interrupt
break;
case HUNTING_FOR_COLOR:
if(colorValue() == RED){
counter = 0;
state = FOUND_RED;
} else if(colorValue() == BLUE){
state = FOUND_BLUE;
} else{
state = HUNTING_FOR_COLOR;
}
break;
case FOUND_RED: //Should this really have a timeout?
if(colorValue() == RED){
state = FOUND_RED;
}else{
counter = 0;
state = LLOST_RED;
}
break;
// FOUND BLUE
case FOUND_BLUE: //3
if(colorValue() == BLUE){
state = FOUND_BLUE;
} else {
counter = 0;
state = LLOST_BLUE;
}
break;
// JUST LOST BLUE, TURNING LEFT
case LLOST_BLUE:
if(colorValue() == BLUE){
state = FOUND_BLUE;
}else if(counter < COUNTER_LENGTH){
counter ++;
state = LLOST_BLUE;
}else{
counter = 0;
state = RLOST_BLUE;
}
break;
// Failed to find blue turning left, turning right instead
case RLOST_BLUE:
if(colorValue() == BLUE){
state = FOUND_BLUE;
} else if(counter < COUNTER_LENGTH * 2){
counter ++;
state = RLOST_BLUE;
}else{
state = HALT;
}
break;
case LLOST_RED:
if(colorValue() == RED){
state = FOUND_RED;
}else if(counter < COUNTER_LENGTH){
counter ++;
state = LLOST_RED;
}else{
counter = 0;
state = RLOST_RED;
}
break;
// Failed to find RED turning left, turning right instead
case RLOST_RED:
if(colorValue() == RED){
state = FOUND_RED;
} else if(counter < COUNTER_LENGTH * 2){
counter ++;
state = RLOST_RED;
}else{
state = HALT;
}
break;
case TURN_AROUND_BLUE:
if(counter > rotateTime){
state = LLOST_BLUE;
}
counter++;
break;
case TURN_AROUND_RED:
if(counter > rotateTime){
state = LLOST_RED;
}
counter++;
break;
// Halting case
default:
state = HALT;
break;
}
}
/*!
* Оптимизация и дополнительная фильтрация токенов.
*/
void HtmlFilter::optimize(QList<HtmlToken> &tokens) const
{
int index = -1;
for (int i = 0; i < tokens.size(); ++i) {
if (!tokens.at(i).simple) {
index = i;
break;
}
}
if (index == -1)
return;
HtmlToken token = tokens.at(index);
if (token.tag == LS("a") || token.tag == LS("font")) {
tokens[index].simple = true;
int gt = endTag(token.tag, tokens, index);
// Если закрывающий тег не найден, удаляем тег.
if (gt == -1) {
tokens.removeAt(index);
return optimize(tokens);
}
// Если закрывающий следует сразу после открывающего, удаляем тег и закрывающий тег.
if (gt - index == 1) {
tokens.removeAt(index);
if (index < tokens.size())
tokens.removeAt(index);
return optimize(tokens);
}
// Удаляем все не текстовые токены внутри тега.
for (int i = gt - 1; i > index; --i) {
if (tokens.at(i).type != HtmlToken::Text) {
tokens.removeAt(i);
gt--;
}
else {
tokens[i].parent = token.tag;
}
}
AbstractTag *tag = 0;
if (token.tag == LS("a"))
tag = new HtmlATag(token);
else if (token.tag == LS("font"))
tag = new HtmlFontTag(token);
if (!tag->valid || gt - index == 1) {
tokens.removeAt(gt);
tokens.removeAt(index);
}
else
tokens[index].text = tag->toText();
delete tag;
return optimize(tokens);
}
/// Тег span в зависимости от css стилей преобразуется в теги b, i, u, s и font
/// и полностью удаляется из текста. Тег font используется для установки цвета элемента.
else if (token.tag == LS("span")) {
QList<HtmlToken> tags;
const Range range = attrBody(LS("style"), token.text);
if (range.first != -1) {
QString value;
if (cssValue(LS("font-weight"), token.text, range, value) && (value == LS("bold") || value == LS("bolder") || value == LS("600") || value == LS("700") || value == LS("800") || value == LS("900")))
tags.append(HtmlToken(HtmlToken::Tag, LS("<b>")));
if (cssValue(LS("font-style"), token.text, range, value) && value == LS("italic"))
tags.append(HtmlToken(HtmlToken::Tag, LS("<i>")));
if (cssValue(LS("text-decoration"), token.text, range, value)) {
if (value == LS("underline"))
tags.append(HtmlToken(HtmlToken::Tag, LS("<u>")));
else if (value == LS("line-through"))
tags.append(HtmlToken(HtmlToken::Tag, LS("<s>")));
}
if (cssValue(LS("color"), token.text, range, value) && colorValue(value)) {
HtmlToken token(HtmlToken::Tag, LS("<font color=\"") + value + LS("\">"));
token.simple = true;
tags.append(token);
}
}
tokens.removeAt(index);
int gt = endTag(token.tag, tokens, index);
if (gt == -1)
return optimize(tokens);
tokens.removeAt(gt);
if (index == gt)
return optimize(tokens);
gt++;
foreach (HtmlToken tag, tags) {
tokens.insert(index, tag);
tokens.insert(gt, tag.toEndTag());
index++;
gt++;
}
void ColorPickerApp::setColors(int furnitureIndex) {
m_furnitureIndex = furnitureIndex;
m_color0->setBrush(colorValue(furnitureIndex, 0));
m_color1->setBrush(colorValue(furnitureIndex, 1));
m_color2->setBrush(colorValue(furnitureIndex, 2));
}