Source: public/javascript/modules/utils.js

  1. import { SPEED_OF_LIGHT, VELOCITY_SHIFT_TYPE, REDSHIFT_SHIFT_TYPE } from "./constants.js";
  3. /*
  4.  ** A set of classes and function definitions utilized by the
  5.  ** differents flavours of OLQV viewers.
  6.  **
  7.  ** Author : M. Caillat
  8.  ** Date : 06th December 2018
  9.  **        07th April 2021
  10.  */
  12. /*
  13.  ** A class to convert a right ascension expressed in decimal degree into an integer value expressing a pixel index.
  14.  */
  15. class RADDtoPixelConverter {
  16.     static enter(what) {
  17.         console.group(this.name + "." + what);
  18.     }
  20.     static exit() {
  21.         console.groupEnd();
  22.     }
  24.     constructor(radd0, radd1, rapix0, rapix1) {
  25.         RADDtoPixelConverter.enter(this.constructor.name);
  26.         this.radd0 = radd0;
  27.         this.rapix0 = rapix0;
  28.         this.slope = (rapix1 - rapix0) / (radd1 - radd0);
  29.         RADDtoPixelConverter.exit();
  30.     }
  32.     convert(radd) {
  33.         RADDtoPixelConverter.enter(this.convert.name);
  34.         var result = this.rapix0 + (radd - this.radd0) * this.slope;
  35.         RADDtoPixelConverter.exit();
  36.         return result;
  37.     }
  38. }
  40. /*
  41.  ** A class to convert a declination expressed in decimal degree into an integer value expressing a pixel index.
  42.  */
  43. class DECDDtoPixelConverter {
  44.     static enter(what) {
  45.         console.group(this.name + "." + what);
  46.     }
  48.     static exit() {
  49.         console.groupEnd();
  50.     }
  52.     constructor(decdd0, decdd1, decpix0, decpix1) {
  53.         DECDDtoPixelConverter.enter(this.constructor.name);
  54.         this.decdd0 = decdd0;
  55.         this.decpix0 = decpix0;
  56.         this.slope = (decpix1 - decpix0) / (decdd1 - decdd0);
  57.         DECDDtoPixelConverter.exit();
  58.     }
  60.     convert(decdd) {
  61.         DECDDtoPixelConverter.enter(this.convert.name);
  62.         var result = this.decpix0 + (decdd - this.decdd0) * this.slope;
  63.         DECDDtoPixelConverter.exit();
  64.         return result;
  65.     }
  66. };
  68. class PixelToAbsConverter {
  69.     static enter(what) {
  70.         console.group(this.name + "." + what);
  71.     }
  73.     static exit() {
  74.         console.groupEnd();
  75.     }
  77.     /**
  78.      * 
  79.      * @param {integer} crpix1 the reference pixel along the first axis ( supposedly RA )
  80.      * @param {float} cdeltInDeg1 the coordinate increment in degree at the reference point along the first axis ( supposedly RA )
  81.      * @param {integer} crpix2 the reference pixel along the second axis ( supposedly DEC )
  82.      * @param {float} cdeltInDeg2 the coordinate increment in degree at the reference point along the second axis ( supposedly DEC )
  83.      * @param {Projection} projection the instance of Projection deduced from the FITS header.
  84.      */
  85.     constructor(crpix1, cdeltInDeg1, crpix2, cdeltInDeg2, projection) {
  86.         this.crpix1 = crpix1;
  87.         this.cdeltInRad1 = cdeltInDeg1 * Math.PI / 180.;
  88.         this.crpix2 = crpix2;
  89.         this.cdeltInRad2 = cdeltInDeg2 * Math.PI / 180.;
  90.         this.projection = projection;
  91.     }
  93.     /**
  94.      * 
  95.      * @param {integer} i an integer expressing the first pixel coordinate on the pixels grid ( supposedly RA )  
  96.      * @param {integer} j an integer expressing the second pixel coordinate on the pixels grid ( supposedly DEC )
  97.      * @returns {float[2]} [<right-ascension-in-degree>, <declination-in-degree>]
  98.      */
  99.     convert(i, j) {
  100.         let aux = this.projection.relToAbs([(i - this.crpix1) * this.cdeltInRad1], [(j - this.crpix2) * this.cdeltInRad2]);
  101.         return ([aux['ra'][0] * 180 / Math.PI, aux['dec'][0] * 180 / Math.PI]);
  102.     }
  104.     /**
  105.      * @param {integer} i an integer expressing the first pixel coordinate on the pixels grid ( supposedly RA )
  106.      * @param {integer} j an integer expressing the second pixel coordinate on the pixels grid ( supposedly DEC )
  107.      * @returns {String[2]} [<string-HMS>, <string-DMS>]
  108.      */
  109.     label(i, j) {
  110.         let [raInDeg, decInDeg] = this.convert(i, j);
  111.         return [DecDeg2HMS(raInDeg), DecDeg2DMS(decInDeg)];
  112.     }
  113. }
  115. class AbsToPixelConverter {
  116.     static enter(what) {
  117.         console.group(this.name + "." + what);
  118.     }
  120.     static exit() {
  121.         console.groupEnd();
  122.     }
  124.     /**
  125.      * 
  126.      * @param {integer} crpix1 the reference pixel along the first axis ( supposedly RA )
  127.      * @param {float} cdelt1 the coordinate increment in radians at the reference point along the first axis ( supposedly RA )
  128.      * @param {integer} crpix2 the reference pixel along the second axis ( supposedly DEC )
  129.      * @param {float} cdelt2 the coordinate increment in radians at the reference point along the second axis ( supposedly DEC )
  130.      * @param {Projection} projection the instance of Projection deduced from the FITS header.
  131.      */
  132.     constructor(crpix1, cdelt1, crpix2, cdelt2, projection) {
  133.         this.crpix1 = crpix1;
  134.         //degrees to radians
  135.         this.cdelt1 = degToRad(cdelt1);
  136.         this.crpix2 = crpix2;
  137.         // degrees to radians
  138.         this.cdelt2 = degToRad(cdelt2);
  139.         this.projection = projection;
  140.     }
  142.     /**
  143.      * 
  144.      * @param {float} x right ascension in radian 
  145.      * @param {float} y right ascention in radian
  146.      * @returns {integer[2]} [<pixel-first-coordinate>, <pixel-second-coordinate>]
  147.      */
  148.     convert(x, y) {
  149.         let aux = this.projection.absToRel([x], [y]);
  150.         let i = this.crpix1 + ((aux["x"][0] / this.cdelt1) - 1);
  151.         let j = this.crpix2 + ((aux["y"][0] / this.cdelt2) - 1);
  152.         return ([Math.round(i), Math.round(j)]);
  153.     }
  154. }
  156. class PixelToDECConverter {
  157.     static enter(what) {
  158.         console.group(this.name + "." + what);
  159.     }
  161.     static exit() {
  162.             console.groupEnd();
  163.         }
  164.         /**
  165.          * 
  166.          * @param {*} refpos        CRVAL3
  167.          * @param {*} refchannel    CRPIX3
  168.          * @param {*} angularoffset CDELT3
  169.          */
  170.     constructor(refpos, refchannel, angularoffset) {
  171.         this.crval3 = refpos;
  172.         this.crpix3 = refchannel;
  173.         this.cdelt3 = angularoffset;
  174.     }
  176.     /**
  177.      * 
  178.      * @param {*} pix 
  179.      */
  180.     convert(pix) {
  181.         var result = this.crval3 + (pix - this.crpix3) * this.cdelt3;
  182.         return result;
  183.     }
  184. };
  186. class PixelToRAConverter {
  187.     static enter(what) {
  188.         console.group(this.name + "." + what);
  189.     }
  191.     static exit() {
  192.             console.groupEnd();
  193.         }
  194.         /**
  195.          * 
  196.          * @param {*} refpos        CRVAL1
  197.          * @param {*} refchannel    CRPIX1
  198.          * @param {*} angularoffset CDELT1
  199.          * @param {*} dec           DEC in degree
  200.          */
  201.     constructor(refpos, refchannel, angularoffset, dec) {
  202.         this.crval1 = refpos;
  203.         this.crpix1 = refchannel;
  204.         this.cdelt1 = angularoffset;
  205.     }
  207.     /**
  208.      *   static enter(what) {
  209.       console.group(this.name + "." + what);
  210.     }
  212.     static exit() {
  213.       console.groupEnd();
  214.     }
  215.      * @param {*} pix 
  216.      */
  217.     convert(pix, dec) {
  218.         let dec_inrad = (dec * Math.PI) / 180;
  219.         var result = this.crval1 + (pix - this.crpix1) * this.cdelt1 / Math.cos(dec_inrad);
  220.         return result;
  221.     }
  222. };
  224. /*
  225.  ** Converts a decimal number expected to represent an angle in degree
  226.  ** into a string expressing a right ascension ( H:M:S)
  227.  */
  228. var DecDeg2HMS = function(deg, sep = ':') {
  229.     //if(any(deg< 0 | deg>360)){stop('All deg values should be 0<=d<=360')}
  230.     //if (deg < 0)
  231.     //deg[deg < 0] = deg[deg < 0] + 360
  232.     const HRS = Math.floor(deg / 15);
  233.     const MIN = Math.floor((deg / 15 - HRS) * 60);
  234.     let SEC = (deg / 15 - HRS - MIN / 60) * 3600;
  235.     SEC = Math.floor(SEC * 1000) / 1000.;
  236.     return HRS + sep + MIN + sep + SEC.toFixed(3);
  237. };
  239. /**
  240.  * Converts a H:M:S value into decimal degrees
  241.  * @param {*} value 
  242.  * @returns 
  243.  */
  244. var HMS2DecDeg = function(value){
  245.     const parts = value.split(":");
  246.     if(parts.length !== 3){
  247.         throw("Invalid format for H:M:S value");
  248.     }else{
  249.         const a = parseInt(parts[0]);
  250.         const b = parseFloat(parts[1])*(1/60);
  251.         const c = parseFloat(parts[2]) * (1/3600);
  252.         return (a + b + c)*15;
  253.     }
  254. };
  256. /*
  257.  ** Converts a decimal number expected to represent an angle in degree
  258.  ** into a string expressing a declination ( D:M:S)
  259.  */
  260. var DecDeg2DMS = function(deg, sep = ':') {
  261.     var sign = deg < 0 ? '-' : '+';
  262.     deg = Math.abs(deg);
  263.     var DEG = Math.floor(deg);
  264.     var MIN = Math.floor((deg - DEG) * 60);
  265.     var SEC = (deg - DEG - MIN / 60) * 3600;
  266.     SEC = Math.floor(SEC * 1000.) / 1000.;
  267.     if (SEC < 0.) SEC = 0.;
  268.     if (SEC > 60) SEC = 60.;
  270.     return (sign + DEG + sep + MIN + sep + SEC.toFixed(3));
  271. };
  273. /**
  274.  * Converts a declination D:M:S into decimal degrees
  275.  * @param {*} value 
  276.  * @returns result in degrees
  277.  */
  278. var DMS2DecDeg = function(value, sep=":"){
  279.     let sign = 1;
  281.     if(value[0] == "-"){
  282.         sign = -1;
  283.     }
  285.     const parts = value.split(sep);
  287.     if(parts.length !== 3){
  288.         throw("Invalid format for D:M:S value");
  289.     }else{
  290.         const a = parseFloat(parts[0]);
  291.         const b = parseFloat(parts[1]) * (1/60);
  292.         const c = parseFloat(parts[2]) * (1/3600);
  293.         
  294.         return (a + b + c)*sign;
  295.     }
  296. };
  298. /*
  299.  ** A class to convert pixels into a string expressing a right ascension.
  300.  **
  301.  ** The constructor establishes the transformation pixels -> HMS
  302.  ** with the given parameter ra0pix, ra1pix ( interval in pixels )
  303.  ** and ra0, ra1 ( the same interval in decimal degrees)
  304.  */
  305. class RaLabelFormatter {
  306.     static enter(what) {
  307.         console.group(this.name + "." + what);
  308.     }
  310.     static exit() {
  311.         console.groupEnd();
  312.     }
  314.     // calculer les vraies coordonnées dans le bon système
  315.     // (sans interpolation linéaire)
  316.     constructor(ra0pix, ra1pix, ra0, ra1) {
  317.         RaLabelFormatter.enter(this.constructor.name);
  318.         this.ra0pix = ra0pix;
  319.         this.ra1pix = ra1pix;
  320.         this.ra0 = ra0;
  321.         this.ra1 = ra1;
  322.         this.slope = ((this.ra1 - this.ra0) / (this.ra1pix - this.ra0pix));
  323.         this.format = this.format.bind(this);
  324.         RaLabelFormatter.exit();
  325.     }
  327.     /*
  328.      ** Returns the string representation of a RA in HMS given its input value in pixels.
  329.      */
  330.     format(rapix) {
  331.         //RaLabelFormatter.enter(this.format.name);
  332.         var res = this.ra0 + (rapix - this.ra0pix) * this.slope;
  333.         //RaLabelFormatter.exit();
  334.         return DecDeg2HMS(res);
  335.     }
  336. };
  338. /*
  339.  ** A class to convert pixels into a string expressing a declination.
  340.  **
  341.  ** The constructor establishes the transformation pixels -> DMS
  342.  ** with the given parameter dec0pix, dec1pix ( interval in pixels )
  343.  ** and dec0, dec1 ( the same interval in decimal degrees)
  344.  */
  345. class DecLabelFormatter {
  346.     static enter(what) {
  347.         console.group(this.name + "." + what);
  348.     }
  350.     static exit() {
  351.         console.groupEnd();
  352.     }
  354.     // calculer les vraies coordonnées dans le bon système
  355.     // (sans interpolation linéaire)
  356.     constructor(dec0pix, dec1pix, dec0, dec1) {
  357.         DecLabelFormatter.enter(this.constructor.name);
  358.         this.dec0pix = dec0pix;
  359.         this.dec1pix = dec1pix;
  360.         this.dec0 = dec0;
  361.         this.dec1 = dec1;
  362.         this.slope = ((this.dec1 - this.dec0) / (this.dec1pix - this.dec0pix));
  363.         this.format = this.format.bind(this);
  364.         DecLabelFormatter.exit();
  365.     }
  367.     format(decpix) {
  368.         //DecLabelFormatter.enter(this.format.name);
  369.         var res = this.dec0 + (decpix - this.dec0pix) * this.slope;
  370.         //DecLabelFormatter.exit();
  371.         return DecDeg2DMS(res);
  372.     }
  373. };
  375. /*
  376.  ** A function which returns the units of a spectrum resulting
  377.  ** from the summation of the pixels values on each plane of a range of RA-DEC planes in a FITS cube.
  378.  */
  379. /*
  380. function summedPixelsSpectrumUnit(unit) {
  381.   switch (unit) {
  382.     case "Jy/beam":
  383.       return "Jy";
  384.       break;
  386.     case "erg/s/cm^2/A/arcsec^2":
  387.       return "erg/s/cm^2/A";
  388.       break;
  390.     default:
  391.       return "";
  392.   }
  393. }
  394. */
  396. /*
  397.  ** A function which returns the units of a 2D array resulting from
  398.  ** the summation of a range of RA-DEC planes in a FITS cube.
  399.  */
  400. function summedPixelsUnit(unit) {
  401.     switch (unit) {
  402.         case "Jy/beam":
  403.             return "Jy/beam * km/s";
  406.         case "erg/s/cm^2/A/arcsec^2":
  407.             return "erg/s/cm^2/arcsec^2";
  409.         case "K (Ta*)":
  410.             return "K.km/s";
  412.         default:
  413.             return "";
  414.     }
  415. }
  417. /*
  418.  ** A function which returns a factor
  419.  ** for the display of physical quantity
  420.  ** The returned values are based on experience rather
  421.  ** than on a purely rational approach
  422.  */
  423. function unitRescale(unit) {
  424.     switch (unit) {
  425.         case "K (Ta*)":
  426.             return 1.0;
  428.         case "Jy/beam":
  429.             return 1.0;
  431.         case "erg/s/cm^2/A/arcsec^2":
  432.             //     return 1e18;
  433.             return 1.;
  435.         case "erg/s/cm^2/A":
  436.             //      return 1e12;
  437.             return 1.;
  439.         default:
  440.             return 1.0;
  442.     }
  443. }
  445. /*
  446.  ** A function which sums the values of a array
  447.  ** between two indices i0 (included ) and i1 ( excluded )
  448.  ** and returns the sum multiplied by a coefficient coeff.
  449.  */
  450. function sumArr(arr, i0, i1, coeff) {
  451.     console.trace();
  452.     console.log(arr);
  453.     
  455.     i0 = Math.max(0, i0);
  456.     i1 = Math.min(arr.length - 1, i1);
  457.     console.log(i0 +  "   " + i1);
  458.     console.log(arr.slice(i0, i1 + 1))
  459.     if (i0 > i1)[i0, i1] = [i1, i0];
  461.     try{
  462.         return coeff * arr.slice(i0, i1 + 1).reduceRight(function(a, b) { return a + b; });
  463.     }catch(exception){
  464.         if(arr.slice(i0, i1 + 1).length === 0)
  465.             alert(`Selected interval [${i0}, ${i1+1}] is out of bound`);
  466.         else
  467.             alert(exception);
  468.     }
  469.         
  470. }
  472. /**
  473.  * Utility.
  474.  * A function which parses a string into an array of floats. The string is expected
  475.  * to be a comma separated list of textual representation of decimal numbers.
  476.  * A range [min, max[ can be provided,  then the values are considered valif if and only if they lie in that range.
  477.  *
  478.  * @param {string} s a comma separated list of textual numbers representations
  479.  * @param {number[2]} range if provided values are checked to lie in the range
  480.  * 
  481.  * @returns {number[]|undefined} an array of float numbers or undefined.
  482. */
  483. function str2FloatArray(s, range = false) {
  484.     let x = s.split(",");
  485.     let w = undefined;
  486.     let result = undefined;
  488.     let y = x.map(function(z) { return parseFloat(z) });
  489.     if (range) {
  490.         w = y.map(function(t) { return (!isNaN(t) && (range[0] <= t) && (t < range[1])) });
  491.     } else {
  492.         w = y.map(function(t) { return true; });
  493.     }
  495.     if (w.reduce(function(accum, u) { return accum && u }, true)) {
  496.         result = y;
  497.     }
  499.     return result;
  500. }
  502. /*
  504.  ** A function which creates a document fragment out of an HTML string and appends it to the content of an existing element.
  505.  ** The HTML string is assumed to describe a single element ( e.g. one signle div, p, etc. ).
  506.  ** Returns the created element.
  507.  */
  508. function createAndAppendFromHTML(html, element) {
  509.     var template = document.createElement('template');
  510.     template.innerHTML = html.trim();
  511.     $(element).append(template.content.cloneNode(true));
  512.     return element.lastChild;
  513. }
  515. function redshift2Velocity(z) {
  516.     // SPEED_OF_LIGHT in m/s
  517.     return z * (SPEED_OF_LIGHT / 1000);
  518. }
  520. function velocity2Redshift(v) {
  521.     // SPEED_OF_LIGHT in m/s
  522.     return v / (SPEED_OF_LIGHT / 1000);
  523. }
  525. /*
  526.  ** Two functions to log when a function is entered and exited
  527.  */
  528. function ENTER() {
  529.     var caller = ENTER.caller;
  530.     if (caller == null) {
  531.         result = "_TOP_";
  532.     } else {
  533.         result = caller.name + ": entering";
  534.     }
  535.     console.log(result + ": entering");
  536. }
  538. function EXIT() {
  539.     var caller = EXIT.caller;
  540.     if (caller == null) {
  541.         result = "_TOP_";
  542.     } else {
  543.         result = caller.name + ": exiting";
  544.     }
  545.     console.log(result + ": exiting");
  546. }
  548. function inRange(x, xmin, xmax) {
  549.     return ((x - xmin) * (x - xmax) <= 0);
  550. }
  552. /*
  553.  
  554.   ** Frequency <-> Velocity derivations.
  555.   **
  556.   ** From https://www.iram.fr/IRAMFR/ARN/may95/node4.html
  557.   */
  559. /*
  560.   ** No verification is done on the values of restfreq and frequency. Both are expected to have realistic values.
  561.   ** frequency and restfreq are expected to by in the same unit (i.e. both in HZ or both in GHZ)
  562.   ** The result is in m/s.
  563.   
  564.  var f2v = function (frequency, restfreq, crval3) {
  565.   return (SPEED_OF_LIGHT * (restfreq - frequency) / restfreq) + crval3;
  566. }*/
  568. var f2v = function(frequency, restfreq, vcenter) {
  569.     return (SPEED_OF_LIGHT * (restfreq - frequency) / restfreq) + vcenter;
  570. }
  573. /*
  574.  ** No verification is done on the values of restfreq and velocity. Both are expected to have realistic values.
  575.  */
  576. var v2f = function(velocity, restfreq, vcenter) {
  577.     return restfreq * (1 - (velocity - vcenter) / SPEED_OF_LIGHT)
  578. }
  580. /*
  581.  ** Frequency to wavelength
  582.  */
  583. var f2lambda = function(frequency) {
  584.     return SPEED_OF_LIGHT / frequency;
  585. }
  587. /*
  588.  ** Revert 1D array.
  589.  */
  590. var revertArray = function(a) {
  591.     var result = [];
  592.     for (let i = 0; i < a.length; i++) {
  593.         result.push(a[a.length - i - 1]);
  594.     }
  595.     return result;
  596. }
  598. /*
  599.  ** Round *original* number to *round* numbers after 0.
  600.  */
  601. var round = function(original, round) {
  602.     var i = 0;
  603.     var r = 1;
  604.     while (i < round) {
  605.         ++i;
  606.         r *= 10;
  607.     }
  608.     return Math.round(original * r) / r;
  609. };
  611. /*
  612.  ** Coordinate tabulators
  613.  **
  614.  **  - crval : value at reference point
  615.  **  - cdelt : increment of abscissa
  616.  **  - crpix : coordinate of reference point
  617.  **  - n : tabulate at point of coordinate n
  618.  */
  619. var linearTabulator = function(crval, cdelt, crpix, n) {
  620.     return crval + (n - crpix) * cdelt;
  621. }
  623. /**
  624.  * Generates a random string 
  625.  * (from https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript)
  626.  * @param {*} s 
  627.  * @returns 
  628.  */
  629. var hashCode = function(s) {
  630.     return s.split("").reduce(function(a, b) { a = ((a << 5) - a) + b.charCodeAt(0); return a & a }, 0);
  631. }
  633. var degToArcsec = function(deg) {
  634.     return deg * 3600;
  635. }
  637. function degToRad(deg) {
  638.     return deg * (Math.PI / 180);
  639. }
  641. /**
  642.  * get the rest value for a frequency according to a redshift or a velocity
  643.  * returns a deep-copy of the array with shifted line values
  644.  * @param {*} frequency 
  645.  * @param {*} value  value used to calculate shift 
  646.  * @param {*} type  redshift or velocity
  647.  */
  648. function unshift(frequency, value, type) {
  649.     let result = null;
  650.     if (type == REDSHIFT_SHIFT_TYPE) {
  651.         result = frequency * (1 + value);
  652.     } else if (type == VELOCITY_SHIFT_TYPE) {
  653.         result = frequency * (1 + (value / (SPEED_OF_LIGHT / 10 ** 3)));
  654.     } else {
  655.         result = frequency;
  656.     }
  657.     return result;
  658. }
  660. /**
  661.  * calculate the shifted value of all the lines in the given array
  662.  * returns a deep-copy of the array with shifted line values
  663.  * @param {*} lines  array of lines
  664.  * @param {*} value  value used to calculate shift 
  665.  * @param {*} type  redshift or velocity
  666.  */
  667. function shift(frequency, value, type) {
  668.     let result = null;
  669.     if (type == REDSHIFT_SHIFT_TYPE) {
  670.         result = frequency / (1 + value);
  671.     } else if (type == VELOCITY_SHIFT_TYPE) {
  672.         result = frequency / (1 + (value / (SPEED_OF_LIGHT / 10 ** 3)));;
  673.     } else {
  674.         alert("Unknown data type");
  675.     }
  676.     return result;
  677. }
  679. /**
  680.  * Compute the search radius in degrees from coordinates
  681.  * to get matching sources in NED
  682.  * 
  683.  * if radius_value is FOV : Returns the max value between abs(RAmax-RAmin) and abs(Decmax-Decmin)
  684.  * else : return radius_value
  685.  * 
  686.  * radius_value : radius in arcmin or "fov"
  687.  * fits_header : FITS_HEADER object
  688.  */
  689. function getRadiusInDegrees(radius_value, fits_header) {
  690.     if (radius_value === "fov") {
  691.         // compute dec min and max in degrees
  692.         let pix2dec = new PixelToDECConverter(fits_header.crval2, fits_header.crpix2, fits_header.cdelt2);
  693.         let dec_min = pix2dec.convert(0);
  694.         let dec_max = pix2dec.convert(fits_header.naxis2);
  696.         //compute ra min and max in degrees
  697.         let pix2ra = new PixelToRAConverter(fits_header.crval1, fits_header.crpix1, fits_header.cdelt1);
  698.         let ra_min = pix2ra.convert(0, dec_min);
  699.         let ra_max = pix2ra.convert(fits_header.naxis1, dec_max);
  701.         // search radius
  702.         let dist_in_ra = Math.abs(ra_min - ra_max);
  703.         let dist_in_dec = Math.abs(ra_min - ra_max);
  705.         return Math.max([dist_in_ra], dist_in_dec)
  706.     } else {
  707.         return radius_value;
  708.     }
  709. }
  711. /**
  712.  * Returns value of L'_Line in K.km/s.pc2, then Mgas is a function of L'_Line
  713.  * @param {*} sline    surface selected in summed pixel spectrum in Jy.km/s
  714.  * @param {*} nu_obs   line observed frequency in GHz
  715.  * @param {*} dl       distance in Mpc (from NED)
  716.  * @param {*} z        redshift
  717.  * @returns 
  718.  */
  719. function getLpLine(sline, nu_obs, dl, z){
  720.     return 3.25e7 * sline * (nu_obs**-2) * (dl**2) * ((1+z)**-3);
  721. }
  723. /**
  724. *Converts K in cm-1 (for energy values)
  725. *  @param {*} energy_in_K
  726. *
  727. */
  728. var KToCm = function(energy_in_K){
  729.     return energy_in_K * 0.695;
  730.   }
  731.   
  732.   /**
  733.   *Converts cm-1 in K (for energy values)
  734. *  @param {*} energy_in_cm
  735.   */
  736.   var cmToK = function(energy_in_cm){
  737.     return energy_in_cm / 0.695;
  738.   }
  740. export {
  741.     hashCode,
  742.     degToRad,
  743.     degToArcsec,
  744.     linearTabulator,
  745.     round,
  746.     revertArray,
  747.     /*f2lambda,*/ v2f,
  748.     f2v,
  749.     inRange,
  750.     velocity2Redshift,
  751.     redshift2Velocity,
  752.     /*ENTER, EXIT, createAndAppendFromHTML, str2FloatArray,*/ sumArr,
  753.     createAndAppendFromHTML,
  754.     str2FloatArray,
  755.     unitRescale,
  756.     summedPixelsUnit,
  757.     DecLabelFormatter,
  758.     RaLabelFormatter,
  759.     DecDeg2DMS,
  760.     DecDeg2HMS,
  761.     HMS2DecDeg,
  762.     DMS2DecDeg,
  763.     PixelToRAConverter,
  764.     PixelToDECConverter,
  765.     AbsToPixelConverter,
  766.     PixelToAbsConverter,
  767.     DECDDtoPixelConverter,
  768.     RADDtoPixelConverter,
  769.     getRadiusInDegrees,
  770.     shift, 
  771.     unshift,
  772.     getLpLine,
  773.     KToCm,
  774.     cmToK
  775. }