/// <summary> /// Convert parsedV2Sequence into a V3 sequence /// </summary> private void importSequenceData() { // instantiate the state machine to process incoming data Vixen2xSequenceImportSM import = new Vixen2xSequenceImportSM(Sequence, parsedV2Sequence.EventPeriod); // the current color is based on the intensity of a three channel group int red = 0; int green = 0; int blue = 0; // for each channel in the V2 sequence for (var currentElementNum = 0; currentElementNum < parsedV2Sequence.ElementCount; currentElementNum++) { // Check to see if we are processing more elements than we have mappings. This showed up as an error for a user if (currentElementNum >= mappings.Count) { Logging.Error("importSequenceData: Trying to process more elements (" + parsedV2Sequence.ElementCount + ") than we have mappings. (" + mappings.Count + ")"); break; } ChannelMapping v2ChannelMapping = mappings[currentElementNum]; // set the channel number and the time for each v2 event. import.OpenChannel(v2ChannelMapping.ElementNodeId, Convert.ToDouble(parsedV2Sequence.EventPeriod)); // Logging.Debug("importSequenceData:currentElementNum: " + currentElementNum); string elementName = v2ChannelMapping.ChannelName; Color currentColor = Color.FromArgb(255, 255, 255); byte currentIntensity = 0; conversionProgressBar.UpdateProgressBar(currentElementNum); Application.DoEvents(); // is this an unmapped output channel? if (Guid.Empty == v2ChannelMapping.ElementNodeId) { // no output channel. Move on to the next input channel continue; } // end no output channel defined // do we have a valid guid conversion? if (false == m_GuidToV2ChanList.ContainsKey(v2ChannelMapping.ElementNodeId)) { Logging.Error("importSequenceData: Configuration error. GUID: '" + v2ChannelMapping.ElementNodeId + "' not found in m_GuidToV2ChanList."); continue; } // is this a valid pixel configuration if ((true == v2ChannelMapping.RgbPixel) && (3 != m_GuidToV2ChanList[v2ChannelMapping.ElementNodeId].Count)) { Logging.Error("importSequenceData: Configuration error. Found '" + m_GuidToV2ChanList[v2ChannelMapping.ElementNodeId].Count + "' V2 channels attached to element '" + elementName + "'. Expected 3(RGB). Converting element to non color mixing mode."); v2ChannelMapping.RgbPixel = false; } // process each event for this V2 channel for (uint currentEventNum = 0; currentEventNum < parsedV2Sequence.EventsPerElement; currentEventNum++) { // get the intensity for this V2 channel currentIntensity = parsedV2Sequence.EventData[currentElementNum * parsedV2Sequence.EventsPerElement + currentEventNum]; // is this an RGB Pixel? if (true == v2ChannelMapping.RgbPixel) { // Only process the RED channel of a three channel pixel if (Color.Red != v2ChannelMapping.DestinationColor) { // this is not the red channel of a pixel continue; } // end not red pixel channel red = 0; green = 0; blue = 0; // process the input colors bound to this output channel foreach (ChannelMapping v2Channel in m_GuidToV2ChanList[v2ChannelMapping.ElementNodeId]) { // Logging.Info("convertMapping: Processing V2 Channel '" + v2Channel.ChannelName + "' color intensity."); switch (v2Channel.DestinationColor.Name) { case "Red": { red = Math.Max(red, parsedV2Sequence.EventData[(Convert.ToInt64(v2Channel.ChannelNumber) - 1) * parsedV2Sequence.EventsPerElement + currentEventNum]); break; } // end Red case "Green": { green = Math.Max(green, parsedV2Sequence.EventData[(Convert.ToInt64(v2Channel.ChannelNumber) - 1) * parsedV2Sequence.EventsPerElement + currentEventNum]); break; } // end Green case "Blue": { blue = Math.Max(blue, parsedV2Sequence.EventData[(Convert.ToInt64(v2Channel.ChannelNumber) - 1) * parsedV2Sequence.EventsPerElement + currentEventNum]); break; } // end Red default: { Logging.Error("importSequenceData pixel conversion processing error. Skipping processing unexpected color '" + v2Channel.DestinationColor.Name + "' for V2 Channel '" + v2Channel.ChannelName + "(" + v2Channel.ChannelNumber + ")'. Color must be one of 'RED', 'GREEN' or 'BLUE'"); break; } // end default } // end switch on color } // end process each V2 channel assigned to the v3 channel // get the max intensity for this v2 channel set currentIntensity = Convert.ToByte(Math.Min((int)255, Math.Max(red, Math.Max(green, blue)))); // Scale the color to full intensity and let the intensity value attenuate it. if (0 != currentIntensity) { double multplier = Convert.ToDouble(byte.MaxValue) / Convert.ToDouble(currentIntensity); red = Math.Min(((int)255), Convert.ToInt32(Convert.ToDouble(red) * multplier)); green = Math.Min(((int)255), Convert.ToInt32(Convert.ToDouble(green) * multplier)); blue = Math.Min(((int)255), Convert.ToInt32(Convert.ToDouble(blue) * multplier)); } // set the final color currentColor = Color.FromArgb(red, green, blue); } // end pixel processing else { // set the non pixel color value currentColor = mappings[currentElementNum].DestinationColor; } // end non pixel processing // process the event through the state machine. import.processEvent(currentEventNum, currentColor, currentIntensity); } // end for each event in the element / channel // close this channel import.closeChannel(); } // end for each input channel } // end importSequenceData
private void importSequenceData() { int startEventPosition = resetEventPosition; var endEventPosition = resetEventPosition; var priorEventNum = resetEventPosition; var startEventValue = zeroEventValue; var endEventValue = zeroEventValue; var priorEventValue = zeroEventValue; var currentEventValue = zeroEventValue; var pbImportValue = 0; // These flags are here just to make the code below easier to read, at least for me. var patternFound = false; var processingSingleEvents = false; var processingGroupEvents = false; var processingRamps = false; var processingFades = false; var currentEventIsZero = true; var currentEventIsNotZero = false; var priorEventisNotZero = false; foreach (patternType pattern in Enum.GetValues(typeof(patternType))) { processingSingleEvents = pattern == patternType.SingleSetLevel; processingGroupEvents = pattern == patternType.SetLevelTrend; processingRamps = pattern == patternType.PulseRampTrend; processingFades = pattern == patternType.PulseFadeTrend; var patternText = ((DescriptionAttribute)((pattern.GetType().GetMember(pattern.ToString()))[0] .GetCustomAttributes(typeof(DescriptionAttribute), false)[0])). Description; currentEventValue = zeroEventValue; for (var currentElementNum = 0; currentElementNum < parsedV2Sequence.ElementCount; currentElementNum++) { conversionProgressBar.StatusLineLabel = string.Format("Finding {0} on Element {1}", patternText, currentElementNum + 1); conversionProgressBar.UpdateProgressBar(++pbImportValue); patternFound = false; priorEventValue = zeroEventValue; priorEventNum = resetEventPosition; for (var currentEventNum = 0; currentEventNum < parsedV2Sequence.EventsPerElement; currentEventNum++) { // To keep the progress bar looking snappy if ((currentEventNum % 10) == 0) { Application.DoEvents(); } currentEventValue = parsedV2Sequence.EventData[currentElementNum * parsedV2Sequence.EventsPerElement + currentEventNum]; currentEventIsZero = currentEventValue == zeroEventValue; currentEventIsNotZero = !currentEventIsZero; priorEventisNotZero = priorEventValue != zeroEventValue; // Add a non zero single set level event. if (processingSingleEvents && currentEventIsNotZero) { addEvent(pattern, currentElementNum, currentEventNum, currentEventValue, currentEventNum); startEventPosition = resetEventPosition; endEventPosition = resetEventPosition; } // Add a ramp, fade or multi set level event since it just ended (a zero event was found) else if (patternFound && !processingSingleEvents && currentEventIsZero && endEventPosition != resetEventPosition) { addEvent(pattern, currentElementNum, startEventPosition, startEventValue, endEventPosition, endEventValue); patternFound = false; startEventPosition = resetEventPosition; endEventPosition = resetEventPosition; } // Beggining of a pattern found, set flag and start event postion and value else if (!patternFound && currentEventNum > resetEventPosition && ((processingGroupEvents && currentEventIsNotZero && currentEventValue == priorEventValue) || (processingFades && currentEventIsNotZero && currentEventValue < priorEventValue) || (processingRamps && priorEventisNotZero && currentEventValue > priorEventValue))) { patternFound = true; startEventPosition = currentEventNum - 1; startEventValue = priorEventValue; endEventPosition = currentEventNum; endEventValue = currentEventValue; } // Pattern continuing, update the end event postion and value. else if (patternFound && ((processingGroupEvents && currentEventValue == priorEventValue) || (processingFades && currentEventValue < priorEventValue) || (processingRamps && priorEventisNotZero && currentEventValue > priorEventValue))) { endEventPosition = currentEventNum; endEventValue = currentEventValue; } // End of a pattern because none of the other conditions were met. else if (patternFound) { addEvent(pattern, currentElementNum, startEventPosition, startEventValue, priorEventNum, priorEventValue); patternFound = false; startEventPosition = resetEventPosition; endEventPosition = resetEventPosition; } priorEventValue = currentEventValue; priorEventNum = currentEventNum; } // for currentEvent // End of the Element, so process any existing patterns. if (patternFound) { addEvent(pattern, currentElementNum, startEventPosition, priorEventValue, priorEventNum); } } // for currentElementNum } // foreach patternType }