/// <summary> /// Return Remove contaminant peak is Enabled. /// </summary> /// <param name="clrParams"></param> /// <returns></returns> public ClrVariant RemoveContaminantPeakIsEnabled(ClrParameters clrParams) { ClrVariant ret = new ClrVariant(); ret.type = ClrVariant.DataType.BOOL; ret.obj = false; try { ClrMsDataVariant msObj = new ClrMsDataVariant(ClrPluginCallTool.getActiveObject(clrParams)); SampleWrapper sw = msObj.getSample(); if (sw != null) { DataGroupNodeWrapper dgnw = sw.getRootDataGroupNode(); if (1 < dgnw.getNumberOfSpectra()) { ret.obj = true; } } } catch { ret.obj = false; } return(ret); }
/// <summary> /// Define of Specified option. /// (This function is not called normally. Please reference design document Page 37.) /// </summary> /// <param name="clrParams"></param> /// <returns></returns> public ClrVariant BatPitchSpecified(ClrParameters clrParams) { // Return value (Success: true, Failure: false) ClrVariant ret = new ClrVariant(); // We initially set ret.prim.boolVal to false so that we can return a false // result easily using "return ret" if a failure condition occurs. ret.type = ClrVariant.DataType.BOOL; ret.obj = false; return(ret); }
/** * @fn kome.clr.ClrVariant SimcaDisplayPluginFunction(kome.clr.ClrParameters* clrParams) * @brief write this function's brief. * @param[in] clrParams ClrParameters object * @return If true, it succeeded (boolean) */ /// <summary> /// Mass++ menu(SimcaDisplay...) execute function /// </summary> /// <param name="clrParams">parameters object</param> /// <returns>This value has no meanings.</returns> public ClrVariant SimcaDisplayPluginFunction(ClrParameters clrParams) { // Return value (Success: true, Failure: false) ClrVariant ret = new ClrVariant(); // We initially set ret.prim.boolVal to false so that we can return a false // result easily using "return ret" if a failure condition occurs. ret.type = ClrVariant.DataType.BOOL; ret.obj = false; // Method write Here SimcaDisplayManager.DisplayMainForm(); ret.obj = true; return(ret); }
/// <summary> /// Remove contaminant peak is Enabled. /// </summary> /// <param name="clrParams">parameters for C# plug-in from Mass++</param> /// <returns></returns> public ClrVariant RemoveContaminantPeak(ClrParameters clrParams) { // Return value (Success: true, Failure: false) ClrVariant ret = new ClrVariant(); // We initially set ret.prim.boolVal to false so that we can return a false // result easily using "return ret" if a failure condition occurs. ret.type = ClrVariant.DataType.BOOL; ret.obj = false; // Convert clrParams to ActiveObject ClrVariant clrVar = ClrPluginCallTool.getActiveObject(clrParams); // Display main window. RemoveContaminantPeakManager.DisplayDlgRemovContamiPeak(clrVar); ret.obj = true; return(ret); }
/// <summary> /// Batch Resampling Entry Function. /// </summary> /// <param name="clrParams"></param> /// <returns></returns> public ClrVariant BatResample(ClrParameters clrParams) { // Return value (Success: true, Failure: false) ClrVariant ret = new ClrVariant(); // We initially set ret.prim.boolVal to false so that we can return a false // result easily using "return ret" if a failure condition occurs. ret.type = ClrVariant.DataType.BOOL; ret.obj = false; // Call Manager int retValue = SpectrumCalculationManager.CommandlineSpecCalc(clrParams); if (retValue == 0) { ret.obj = true; // Success. } else { ret.obj = false; // Failure. } return(ret); }
private bool CreateBaselineSubtractedXIC( PluginFunctionItemWrapper pfiw, List <ClrDataPoints> resamplingList, List <SpectrumWrapper> ms1List, SettingParameterValuesWrapper spvw, ref ClrDataPoints[] subtractLowerXICList, ref ClrDataPoints[] subtractHigherXICList, ref ClrDataPoints subtractHighestXICList ) { uint resamplingLength = resamplingList[0].getLength(); int lowerIndex = (resamplingLength < int.MaxValue) ? (int)resamplingLength : int.MaxValue; int higherIndex = (0 < (int)(resamplingLength - lowerIndex))? (int)(resamplingLength - lowerIndex) : 0; subtractLowerXICList = new ClrDataPoints[lowerIndex]; subtractHigherXICList = new ClrDataPoints[higherIndex]; for (uint i = 0; i < resamplingLength; i++) { //Update message. if (UpdateProgress != null) { UpdateProgress( PROGRESS_REMOVECONTAMINANT_PHASE.REMOVE_CONTAMINANT_PEAK, (int)i, (int)resamplingLength); } //Cancel. if (StopFlag) { break; } //Create XIC. ClrDataPoints pts = new ClrDataPoints(); for (int j = 0; j < resamplingList.Count; j++) { //Cancel. if (StopFlag) { break; } pts.addPoint(ms1List[j].getRt(), resamplingList[j].getY(i)); } //Cancel. if (StopFlag) { pts.clearPoints(); pts.Dispose(); break; } //Baseline Subtraction ClrParameters param = new ClrParameters(); ClrDataPoints baseline = new ClrDataPoints(); ClrPluginCallTool.setXYData(param, pts); ClrPluginCallTool.setBaseline(param, baseline); ClrPluginCallTool.setSettingValues(param, spvw); pfiw.getCall().invoke(param); //Cancel. if (StopFlag) { param.Dispose(); baseline.clearPoints(); baseline.Dispose(); } //Resampling baseline. ClrDataPoints subtracted = new ClrDataPoints(); ResamplingParameter resamplingParam = new ResamplingParameter(); ResamplingCalculation resamplingCalc = new ResamplingCalculation(resamplingParam); resamplingParam.ResamplingMode = ResamplingParameter.SamplingMode.FIRST; resamplingParam.Interpolation = _resamplingParam.Interpolation; resamplingParam.AddXYData(pts); resamplingParam.AddXYData(baseline); resamplingCalc.Execute(); ClrDataPoints resampledBaseline = resamplingCalc.Result.getResultData(1); for (uint j = 0; j < resampledBaseline.getLength(); j++) { double intensity = Math.Max(pts.getY(j) - resampledBaseline.getY(j), 0); subtracted.addPoint(pts.getX(j), intensity); } // Countermeasure to OutOfBoundsException. if (i < int.MaxValue) { subtractLowerXICList[i] = subtracted; } else if (int.MaxValue < i && i < (uint)int.MaxValue * 2) { subtractHigherXICList[i - int.MaxValue] = subtracted; } else { subtractHighestXICList = subtracted; } resamplingParam.ClearXYDataList(); resamplingCalc.Result.ClearXYDataList(); } return(!StopFlag); }
/// <summary> /// Commandline Spec Calc. /// </summary> /// <param name="clrParams"></param> /// <returns>0:success, 1:fail</returns> public static int CommandlineSpecCalc(ClrParameters clrParams) { kome.clr.ClrLogger log = kome.clr.ClrLogger.getInstance(); // Return value (Success: true, Failure: false) int ret = 0; // We initially set ret.prim.boolVal to false so that we can return a false // result easily using "return ret" if a failure condition occurs. // progress bar kome.clr.ProgressWrapper progress = null; kome.clr.DisplayProgressWrapper display_progress = new DisplayProgressWrapper(PROGRESS_TITLE); progress = display_progress; progress.createSubProgresses(2); // Divide Progress bar into 2 sections. subProgress = progress.getSubProgress(0); // Get first Sub progress. subProgress.setRange(0, 5); // Set value between 0 to 5. // start string[] strArrayParam = new string[NUMBER_OF_MAX_PARAM]; // Store 5 parameters without conversion. bool flgTryParseSpecifiedInterval = true; // If failed to convert to dSpecifiedInterval, set true. double dSpecifiedInterval = -1; // Store the parameter of specified[999.99] option. kome.clr.SettingParameterValuesWrapper settings = kome.clr.ClrPluginCallTool.getSettingValues(clrParams); kome.clr.PluginManagerWrapper plgMgr = kome.clr.PluginManagerWrapper.getInstance(); if (settings == null) { //Unexpected Error log.errorCode(ERROR_UNEXPECTED, ERROR_CODE_UNEXPECTED); return(1); // Failed. } // Get the number of parameters. uint uNumberOfParameters = settings.getNumberOfParameters(); //Get parameters. for (uint i = 0; i < uNumberOfParameters; i++) { string strParamName = settings.getParameterName(i); string strParamValue = settings.getParameterValue(strParamName); if (i < NUMBER_OF_MAX_PARAM) { strArrayParam[i] = strParamValue; // Store parameter. } // If strParamName is not "sampling pitch", it has not potential that has parameter. if (strParamName != PARAMETER_NAME_SAMPLING_PITCH) { continue; } // The case that strParamName equals sampling pitch. uint uNumberOfFunctionItems = plgMgr.getNumberOfFunctionItems(FUNCTION_TYPE_SAMPLING_PITCH); for (uint j = 0; j < uNumberOfFunctionItems; j++) { kome.clr.PluginFunctionItemWrapper item = plgMgr.getFunctionItem(FUNCTION_TYPE_SAMPLING_PITCH, j); string strLongName = item.getLongName(); if ((item.getShortName() != strParamValue) || (item.getSettingsPage() == null)) { continue; } kome.clr.SettingParameterValuesWrapper settingsSub2 = settings.getSubParameterValues(strParamName, strParamValue); uint uNumberOfSubParameters = settingsSub2.getNumberOfParameters(); string strSubParamName = settingsSub2.getParameterName(0); string strSubParamValue = settingsSub2.getParameterValue(strSubParamName); if (!double.TryParse(strSubParamValue, out dSpecifiedInterval)) { // Convert failed. dSpecifiedInterval = -1; flgTryParseSpecifiedInterval = false; } } } // Commandline parameter getting... ResamplingParameter param = new ResamplingParameter(); // (1)File Spectrum Name string strSpectrumName = strArrayParam[(int)BatchParamType.FILE_SPECTRUM_NAME]; // (2)Operation Type string strOperationType = strArrayParam[(int)BatchParamType.OPERATION_TYPE]; // (3)Sampling Pitch string strSamplingPitch = strArrayParam[(int)BatchParamType.SAMPLING_PITCH]; // (4)Output Range string strOutputRange = strArrayParam[(int)BatchParamType.OUTPUT_RANGE]; // (5)Interpolate Algorithm string strInterpolateAlgorithm = strArrayParam[(int)BatchParamType.INTERPOLATE_ALGORITHM]; // Commandline parameter TryParse... //////// bool bRet; // return of TryParse. // Postpone Processing for (1)File Spectrum Name. // (2)Operation Type BatchParamOperationType resultOperationType; bRet = Enum.TryParse <BatchParamOperationType>(strOperationType.ToUpper(), out resultOperationType); if (bRet == false) { // error log.errorCode(string.Format(ERROR_FORMAT_OPERATION_TYPE, strOperationType), ERROR_CODE_OPERATION_TYPE); return(1); // Failed to convert. } SpectrumCalculation.Cal.SpectrumCalculation.OperationSettings resultOperationSetting; resultOperationSetting = (SpectrumCalculation.Cal.SpectrumCalculation.OperationSettings)resultOperationType; // AVERAGE, SUBTRACT, SUM, DIVIDE are the operation type option. log.debug(string.Format(DEBUG_LOG_OPERATION_TYPE, resultOperationSetting)); subProgress.setPosition(1); // (3)Sampling Pitch BatchParamSamplingPitchType resultSamplingPitch; bRet = Enum.TryParse <BatchParamSamplingPitchType>(strSamplingPitch.ToUpper(), out resultSamplingPitch); if (bRet == false) { // error log.errorCode(string.Format(ERROR_FORMAT_SAMPLING_PITCH, strSamplingPitch), ERROR_CODE_SAMPLING_PITCH); return(1); // Failed to convert. } ResamplingParameter.SamplingMode resultResamplingMode; resultResamplingMode = (ResamplingParameter.SamplingMode)resultSamplingPitch; // Convert FIRST,MINIMUIM,AVERAGE,SPECIFIED into internal value. log.debug(string.Format(DEBUG_LOG_SAMPLING_PITCH, resultResamplingMode)); param.ResamplingMode = resultResamplingMode; if (resultSamplingPitch == BatchParamSamplingPitchType.SPECIFIED) { if (!flgTryParseSpecifiedInterval) { //error return(1); } param.SpecifiedInterval = dSpecifiedInterval; log.debug(string.Format(DEBUG_LOG_SPECIFIED_INTERVAL, dSpecifiedInterval)); } else { param.SpecifiedInterval = null; log.debug(string.Format(DEBUG_LOG_SPECIFIED_INTERVAL, NULL_STRING)); } subProgress.setPosition(2); // (4)Output Range string strOutputRangeLow; string strOutputRangeHi; double dOutputRangeLow = 0; double dOutputRangeHi = 0; string[] arrystrSeparatedOutputRange = kome.clr.SettingsValueWrapper.separateListValue(strOutputRange); if (2 == arrystrSeparatedOutputRange.Length) { strOutputRangeLow = arrystrSeparatedOutputRange[0]; strOutputRangeHi = arrystrSeparatedOutputRange[1]; } else { //error log.errorCode(string.Format(ERROR_FORMAT_RANGE, strOutputRange), ERROR_CODE_OUTPUT_RANGE); return(1); } if (double.TryParse(strOutputRangeLow, out dOutputRangeLow)) { param.OutputLowerRange = dOutputRangeLow; log.debug(string.Format(DEBUG_LOG_RANGE_LOW, param.OutputLowerRange)); } else { param.OutputLowerRange = null; log.debug(string.Format(DEBUG_LOG_RANGE_LOW, NULL_STRING)); } if (double.TryParse(strOutputRangeHi, out dOutputRangeHi)) { param.OutputHigherRange = dOutputRangeHi; log.debug(string.Format(DEBUG_LOG_RANGE_HIGH, param.OutputHigherRange)); } else { param.OutputHigherRange = null; log.debug(string.Format(DEBUG_LOG_RANGE_HIGH, NULL_STRING)); } subProgress.setPosition(3); // (5)Interpolate Algorithm BatchParamInterpolateAlgorithmType resultInterpolateAlgorithm; bRet = Enum.TryParse <BatchParamInterpolateAlgorithmType>(strInterpolateAlgorithm.ToUpper(), out resultInterpolateAlgorithm); if (bRet == false) { // error log.errorCode(string.Format(ERROR_FORMAT_INTERPOLATE, strInterpolateAlgorithm), ERROR_CODE_INTERPOLATE); return(1); } log.debug(string.Format(DEBUG_LOG_INTERPOLATE, resultInterpolateAlgorithm)); ResamplingParameter.InterpolationAlgorithm resultInterpolation; resultInterpolation = (ResamplingParameter.InterpolationAlgorithm)resultInterpolateAlgorithm; param.Interpolation = resultInterpolation; subProgress.setPosition(4); //param.ErrorMessage = ERROR_GENERAL_PURPOSE; // Create ResamplingParameter is Complete. // Assign to SpectrumCalculation(). SpectrumCalculation.Cal.SpectrumCalculation calc = new Cal.SpectrumCalculation(param); calc.OperationSetting = resultOperationSetting; // (2)Operation Type // (1)File Spectrum Name AddSpectrumFromParameter(calc, strSpectrumName); subProgress.setPosition(5); subProgress.fill(); subProgress = progress.getSubProgress(1); // Get first sub progress. calc.GetResamplingCalculation.UpdateResamplingProgress += UpdateSpecCalcResamplingProgressCmd; try { calc.Execute(); } catch (ArgumentException ex) { log.errorCode(string.Format(ERROR_FORMAT_PARAMETER, ex.Message), ERROR_CODE_PARAMETER); return(1); } subProgress.fill(); // Set Spectrum calculation result to active object. SetResultToActiveObject(calc.GetResultSpecCalculation); return(ret); // success. }