/// <summary> /// return an index page according to the inputs /// </summary> /// <returns></returns> public ActionResult IndexWithInputs() { dynamic obj = GetJsonObject(Request.InputStream); // retrieve the quant QuantizationFactorsArray quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); EntropyAlgorithm algorithm = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); _viewModel = new RFXDecodeViewModel(); // Updates parameters ((RFXDecodeViewModel)_viewModel).ProvideParam(quantArray, algorithm); Triplet <string> triplet = JsonHelper.RetrieveTriplet(obj.Inputs); ((RFXDecodeViewModel)_viewModel).ProvidePanelInputs(triplet.ToArray()); var envValues = new Dictionary <string, object>() { { ModelKey, _viewModel }, { isModelValid, true } }; SaveToSession(envValues); return(new HttpStatusCodeResult(HttpStatusCode.OK)); }
public ActionResult Decode() { dynamic obj = GetJsonObject(Request.InputStream); // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); string decOrHex = (string)obj.Params.DecOrHex; Tile tile = null; if (decOrHex.Equals("hex")) { tile = Tile.FromStrings(new Triplet <string>( obj.Inputs.Y, obj.Inputs.Cb, obj.Inputs.Cr), new HexTileSerializer()); } else { tile = Tile.FromStrings(new Triplet <string>( obj.Inputs.Y, obj.Inputs.Cb, obj.Inputs.Cr), new IntegerTileSerializer()); } _codecAction.DoAction(tile); return(new HttpStatusCodeResult(HttpStatusCode.OK)); }
public async Task <IActionResult> IndexWithInputs() { try { using (var bodyStream = new StreamReader(Request.Body)) { var bodyText = await bodyStream.ReadToEndAsync(); dynamic obj = JsonConvert.DeserializeObject(bodyText); // retrieve the quant QuantizationFactorsArray quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); EntropyAlgorithm algorithm = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); _viewModel = new RFXDecodeViewModel(); // Updates parameters ((RFXDecodeViewModel)_viewModel).ProvideParam(quantArray, algorithm); Triplet <string> triplet = JsonHelper.RetrieveTriplet(obj.Inputs); ((RFXDecodeViewModel)_viewModel).ProvidePanelInputs(triplet.ToArray()); var envValues = new Dictionary <string, object>() { { ModelKey, _viewModel }, { isModelValid, true } }; SaveToSession(envValues); } return(Json(ReturnResult <string> .Success("Success"))); } catch (Exception ex) { return(Json(ReturnResult <string> .Fail(ex.Message))); } }
public async Task <IActionResult> Encode() { try { using (var bodyStream = new StreamReader(Request.Body)) { var bodyText = await bodyStream.ReadToEndAsync(); dynamic obj = JsonConvert.DeserializeObject(bodyText); var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); // TODO: error handle var encodeImagePath = this.HttpContext.Session.Get <string>(EncodedImage); if (string.IsNullOrEmpty(encodeImagePath)) { throw new FileNotFoundException("No image found, image size should less than 1MB, please check and try again."); } var tile = Tile.FromFile(encodeImagePath); _codecAction.DoAction(tile); return(Json(ReturnResult <string> .Success("Success"))); } } catch (Exception ex) { return(Json(ReturnResult <string> .Fail(ex.Message))); } }
public async Task <IActionResult> Encode() { try { using (var bodyStream = new StreamReader(Request.Body)) { var bodyText = await bodyStream.ReadToEndAsync(); dynamic obj = JsonConvert.DeserializeObject(bodyText); // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; // retrive the progressive quants var progQuantList = new List <QuantizationFactorsArray>(); foreach (var layer in obj.Params.ProgQuantizationArray) { var layerQuants = JsonHelper.RetrieveQuantsArray(layer); progQuantList.Add(layerQuants); } var progQuantarray = new ProgressiveQuantizationFactors { ProgQuants = progQuantList }; _codecAction.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANT_LIST] = progQuantarray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); _codecAction.Parameters[Constants.PARAM_NAME_USE_REDUCE_EXTRAPOLATE] = JsonHelper.CastTo <UseReduceExtrapolate>(obj.Params.UseReduceExtrapolate); // TODO: error handle var preFramePath = this.HttpContext.Session.Get <string>(PreviousFrameImage); Frame preFrame = Utility.GetPreviousFrame(preFramePath, _codecAction.Parameters); var encodeImagePath = this.HttpContext.Session.Get <string>(EncodedImage); var tile = Tile.FromFile(encodeImagePath); ICodecAction diffing = _codecAction.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PENCODE_NAME_SUBBANDDIFFING)); diffing.Parameters[Constants.PARAM_NAME_PREVIOUS_FRAME] = preFrame; _codecAction.DoAction(new[] { tile }); } return(Json(ReturnResult <string> .Success("Success"))); } catch (Exception ex) { return(Json(ReturnResult <string> .Fail(ex.Message))); } }
public ActionResult IndexWithInputs() { dynamic obj = GetJsonObject(Request.InputStream); foreach (var input in obj) { // TODO: refine this if (input != null && input.Inputs != null) { int layer = JsonHelper.CastTo <int>(input.Layer); if (layer == 0) { // TODO: refine this // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(input.Params.QuantizationFactorsArray); // retrive the progressive quants var progQuantList = new List <QuantizationFactorsArray>(); foreach (var layerQuant in input.Params.ProgQuantizationArray) { var layerQuants = JsonHelper.RetrieveQuantsArray(layerQuant); progQuantList.Add(layerQuants); } var progQuantarray = new ProgressiveQuantizationFactors { ProgQuants = progQuantList }; EntropyAlgorithm algorithm = JsonHelper.CastTo <EntropyAlgorithm>(input.Params.EntropyAlgorithm); UseDifferenceTile useDifferenceTile = JsonHelper.CastTo <UseDifferenceTile>(input.Params.UseDifferenceTile); UseReduceExtrapolate useReduceExtrapolate = JsonHelper.CastTo <UseReduceExtrapolate>(input.Params.UseReduceExtrapolate); _viewModel = new RFXPDecodeViewModel(0); ((RFXPDecodeViewModel)_viewModel).ProvideParam(quantArray, progQuantarray, algorithm, useDifferenceTile, useReduceExtrapolate); ((RFXPDecodeViewModel)_viewModel).ProvidePanelInputs(layer, input.Inputs[0], input.Inputs[1], input.Inputs[2]); Session[ModelKey] = _viewModel; Session[isPreFrameValid] = true; } Decode(input); // Updates Decode Status UpdateDecodeStatus(layer); } } Session[IsValid] = true; return(new HttpStatusCodeResult(HttpStatusCode.OK)); }
public async Task <IActionResult> Decode() { try { using (var bodyStream = new StreamReader(Request.Body)) { var bodyText = await bodyStream.ReadToEndAsync(); dynamic obj = (JObject)JsonConvert.DeserializeObject(bodyText); // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); string decOrHex = (string)obj.Params.DecOrHex; Tile tile = null; JObject jsonInputs = JObject.Parse(obj["Inputs"].ToString()); dynamic objInputs = JsonConvert.DeserializeObject(jsonInputs.ToString()); string y = jsonInputs["Y"].ToString(); string cb = jsonInputs["Cb"].ToString(); string cr = jsonInputs["Cr"].ToString(); if (decOrHex.Equals("hex")) { tile = Tile.FromStrings(new Triplet <string>(y, cb, cr), new HexTileSerializer()); } else { tile = Tile.FromStrings(new Triplet <string>(y, cb, cr), new IntegerTileSerializer()); } _codecAction.DoAction(tile); return(Json(ReturnResult <string> .Success("Success"))); } } catch (Exception ex) { return(Json(ReturnResult <string> .Fail(ex.Message))); } }
public ActionResult Encode() { dynamic obj = GetJsonObject(Request.InputStream); // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; // retrive the progressive quants var progQuantList = new List <QuantizationFactorsArray>(); foreach (var layer in obj.Params.ProgQuantizationArray) { var layerQuants = JsonHelper.RetrieveQuantsArray(layer); progQuantList.Add(layerQuants); } var progQuantarray = new ProgressiveQuantizationFactors { ProgQuants = progQuantList }; _codecAction.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANT_LIST] = progQuantarray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); _codecAction.Parameters[Constants.PARAM_NAME_USE_REDUCE_EXTRAPOLATE] = JsonHelper.CastTo <UseReduceExtrapolate>(obj.Params.UseReduceExtrapolate); // TODO: error handle var preFramePath = (string)Session[PreviousFrameImage]; Frame preFrame = Utility.GetPreviousFrame(preFramePath, _codecAction.Parameters); var encodeImagePath = (string)Session[EncodedImage]; var tile = Tile.FromFile(encodeImagePath); ICodecAction diffing = _codecAction.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PENCODE_NAME_SUBBANDDIFFING)); diffing.Parameters[Constants.PARAM_NAME_PREVIOUS_FRAME] = preFrame; _codecAction.DoAction(new[] { tile }); return(new HttpStatusCodeResult(HttpStatusCode.OK)); }
public ActionResult Encode() { dynamic obj = GetJsonObject(Request.InputStream); // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); // TODO: error handle var encodeImagePath = (string)Session[EncodedImage]; var tile = Tile.FromFile(encodeImagePath); _codecAction.DoAction(tile); return(new HttpStatusCodeResult(HttpStatusCode.OK)); }
public virtual ActionResult Recompute([FromBody] RecomputeRequest request) { // gets the action with the same name as the argument var action = _codecAction.SubActions.FirstOrDefault(c => c.Name.Equals(request.Action)); // if action not found if (action == null) { return(Json(ReturnResult <string> .Fail("Action not found"))); } // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(request.Params.QuantizationFactorsArray); foreach (var _action in _codecAction.SubActions) { _action.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; _action.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(request.Params.EntropyAlgorithm); } // retrive tiles from Inputs var tileList = new List <Tile>(); foreach (var tileJson in request.Inputs) { Triplet <string> triplet = JsonHelper.RetrieveTriplet(tileJson); string dataFormat = request.Params.UseDataFormat; Tile tile = null; if (dataFormat.Equals(Constants.DataFormat.HEX)) { tile = Tile.FromStrings(triplet, new HexTileSerializer()); } else { tile = Tile.FromStrings(triplet, new IntegerTileSerializer()); } if (dataFormat.Equals(Constants.DataFormat.FixedPoint_11_5)) { tile.RightShift(5); } if (dataFormat.Equals(Constants.DataFormat.FixedPoint_12_4)) { tile.RightShift(4); } tileList.Add(tile); } var result = action.DoAction(tileList.FirstOrDefault()); // recompute the following steps and update bool following = false; Tile input = result; foreach (var act in _codecAction.SubActions) { if (following) { result = act.DoAction(input); input = result; } else { if (act.Name.Equals(request.Action)) { following = true; } } } return(Json(ReturnResult <string> .Success("Success"))); }
public override ActionResult Recompute() { // TODO: Add parameters obtain into a function dynamic obj = GetJsonObject(Request.InputStream); string name = JsonHelper.CastTo <string>(obj.Action); // gets the action with the same name as the argument var action = _codecAction.SubActions.SingleOrDefault(c => c.Name.Equals(name)); // if action not found if (action == null) { return(new HttpStatusCodeResult(HttpStatusCode.NotFound)); } // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; // retrive the progressive quants var progQuantList = new List <QuantizationFactorsArray>(); foreach (var layer in obj.Params.ProgQuantizationArray) { var layerQuants = JsonHelper.RetrieveQuantsArray(layer); progQuantList.Add(layerQuants); } var progQuantarray = new ProgressiveQuantizationFactors { ProgQuants = progQuantList }; _codecAction.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANT_LIST] = progQuantarray; _codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); _codecAction.Parameters[Constants.PARAM_NAME_USE_REDUCE_EXTRAPOLATE] = JsonHelper.CastTo <UseReduceExtrapolate>(obj.Params.UseReduceExtrapolate); // TODO: error handle var preFramePath = (string)Session[PreviousFrameImage]; Frame preFrame = Utility.GetPreviousFrame(preFramePath, _codecAction.Parameters); ICodecAction diffing = _codecAction.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PENCODE_NAME_SUBBANDDIFFING)); diffing.Parameters[Constants.PARAM_NAME_PREVIOUS_FRAME] = preFrame; // retrive tiles from Inputs var tileList = new List <Tile>(); foreach (var tileJson in obj.Inputs) { Triplet <string> triplet = JsonHelper.RetrieveTriplet(tileJson); string dataFormat = obj.Params.UseDataFormat; Tile tile = null; if (dataFormat.Equals(Constants.DataFormat.HEX)) { tile = Tile.FromStrings(triplet, new HexTileSerializer()); } else { tile = Tile.FromStrings(triplet, new IntegerTileSerializer()); } if (dataFormat.Equals(Constants.DataFormat.FixedPoint_11_5)) { tile.RightShift(5); } if (dataFormat.Equals(Constants.DataFormat.FixedPoint_12_4)) { tile.RightShift(4); } tileList.Add(tile); } var result = action.DoAction(tileList.ToArray()); // recompute the following steps and update bool following = false; Tile[] input = result; foreach (var act in _codecAction.SubActions) { if (following) { result = act.DoAction(input); input = result; } else { if (act.Name.Equals(name)) { following = true; } } } // TODO: recompute the following steps and update return(new HttpStatusCodeResult(HttpStatusCode.OK)); }
private ICodecAction GetDecoderWithParameters(dynamic obj) { ICodecAction _rfxPDecode = new RFXPDecode(); int layer = JsonHelper.CastTo <int>(obj.Layer); // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(obj.Params.QuantizationFactorsArray); _rfxPDecode.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray; // retrive the progressive quants var progQuantList = new List <QuantizationFactorsArray>(); foreach (var layerQuant in obj.Params.ProgQuantizationArray) { var layerQuants = JsonHelper.RetrieveQuantsArray(layerQuant); progQuantList.Add(layerQuants); } var progQuantarray = new ProgressiveQuantizationFactors { ProgQuants = progQuantList }; _rfxPDecode.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANT_LIST] = progQuantarray; _rfxPDecode.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(obj.Params.EntropyAlgorithm); _rfxPDecode.Parameters[Constants.PARAM_NAME_USE_DIFFERENCE_TILE] = JsonHelper.CastTo <UseDifferenceTile>(obj.Params.UseDifferenceTile); _rfxPDecode.Parameters[Constants.PARAM_NAME_USE_REDUCE_EXTRAPOLATE] = JsonHelper.CastTo <UseReduceExtrapolate>(obj.Params.UseReduceExtrapolate); if (layer == 0) { // Session used to store DAS and previous codec Tile DAS = Tile.FromArrays <short>(new Triplet <short[]>( new short[Tile.TileSize * Tile.TileSize], new short[Tile.TileSize * Tile.TileSize], new short[Tile.TileSize * Tile.TileSize]) ); Dictionary <int, ICodecAction> CodecActionDic = new Dictionary <int, ICodecAction>(); Session[ConstantDAS] = DAS; Session[ConstantCodecActionDic] = CodecActionDic; Session[ConstantDASDic] = new Dictionary <int, Tile>(); // TODO: error handle var preFramePath = (string)Session[PreviousFrameImage]; Frame preFrame = Utility.GetPreviousFrame(preFramePath, _rfxPDecode.Parameters); Session[DecodePreviousFrame] = preFrame; Session[PreviousFrameDic] = new Dictionary <int, Frame>(); } // TODO: deal with null // Add current codecAction in the session Dictionary <int, ICodecAction> SessionCodecActionDic = (Dictionary <int, ICodecAction>)Session[ConstantCodecActionDic]; SessionCodecActionDic[layer] = _rfxPDecode; var EncodeType = layer == 0 ? CodecToolSet.Core.EncodedTileType.EncodedType.FirstPass : CodecToolSet.Core.EncodedTileType.EncodedType.UpgradePass; ICodecAction rlgrSRLDecode = _rfxPDecode.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PDECODE_NAME_RLGRSRLDECODE)); rlgrSRLDecode.Parameters[Constants.PARAM_NAME_ENCODED_TILE_TYPE] = new CodecToolSet.Core.EncodedTileType { Type = EncodeType }; QuantizationFactorsArray progQuant = progQuantarray.ProgQuants[layer]; ICodecAction progDeQuantization = _rfxPDecode.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PDECODE_NAME_PROGRESSIVEDEQUANTIZATION)); progDeQuantization.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANTS] = progQuant; ICodecAction subbandDiffing = _rfxPDecode.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PDECODE_NAME_SUBBANDDIFFING)); Frame preframe = (Frame)Session[DecodePreviousFrame]; subbandDiffing.Parameters[Constants.PARAM_NAME_PREVIOUS_FRAME] = preframe; subbandDiffing.Parameters[Constants.PARAM_NAME_ENCODED_TILE_TYPE] = new CodecToolSet.Core.EncodedTileType { Type = EncodeType }; ICodecAction DeQuantization = _rfxPDecode.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PDECODE_NAME_DEQUANTIZATION)); // deal with some intermediate parameters if (layer >= 1) { rlgrSRLDecode.Parameters[Constants.PARAM_NAME_DAS] = new Frame { Tile = (Tile)Session[ConstantDAS] }; rlgrSRLDecode.Parameters[Constants.PARAM_NAME_PREVIOUS_PROGRESSIVE_QUANTS] = progQuantarray.ProgQuants[layer - 1]; rlgrSRLDecode.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANTS] = progQuantarray.ProgQuants[layer]; } return(_rfxPDecode); }
public async Task <IActionResult> IndexWithInputs() { try { using (var bodyStream = new StreamReader(Request.Body)) { var bodyText = await bodyStream.ReadToEndAsync(); dynamic obj = JsonConvert.DeserializeObject(bodyText); foreach (var input in obj) { // TODO: refine this if (input != null && input.Inputs != null) { int layer = JsonHelper.CastTo <int>(input.Layer); if (layer == 0) { // TODO: refine this // retrieve the quant var quantArray = JsonHelper.RetrieveQuantsArray(input.Params.QuantizationFactorsArray); // retrive the progressive quants var progQuantList = new List <QuantizationFactorsArray>(); foreach (var layerQuant in input.Params.ProgQuantizationArray) { var layerQuants = JsonHelper.RetrieveQuantsArray(layerQuant); progQuantList.Add(layerQuants); } var progQuantarray = new ProgressiveQuantizationFactors { ProgQuants = progQuantList }; EntropyAlgorithm algorithm = JsonHelper.CastTo <EntropyAlgorithm>(input.Params.EntropyAlgorithm); UseDifferenceTile useDifferenceTile = JsonHelper.CastTo <UseDifferenceTile>(input.Params.UseDifferenceTile); UseReduceExtrapolate useReduceExtrapolate = JsonHelper.CastTo <UseReduceExtrapolate>(input.Params.UseReduceExtrapolate); _viewModel = new RFXPDecodeViewModel(0); ((RFXPDecodeViewModel)_viewModel).ProvideParam(quantArray, progQuantarray, algorithm, useDifferenceTile, useReduceExtrapolate); JArray jsonInputs = JArray.Parse(input["Inputs"].ToString()); ((RFXPDecodeViewModel)_viewModel).ProvidePanelInputs(layer, jsonInputs[0].TrimEnter(), jsonInputs[1].TrimEnter(), jsonInputs[2].TrimEnter()); this.HttpContext.Session.SetObject(ModelKey, _viewModel); this.HttpContext.Session.SetObject(isPreFrameValid, true); } Decode(input); // Updates Decode Status await UpdateDecodeStatus(layer); } } } this.HttpContext.Session.SetObject(IsValid, true); return(Json(ReturnResult <string> .Success("Success"))); } catch (Exception ex) { return(Json(ReturnResult <string> .Fail(ex.Message))); } }