| ingra |
Clase base de la librería ingra |
|
Básicos numéricos (M) |
| ingra.red (num, dec) |
Redondea num a dec decimales. dec==null coma flotante, dec<0 redondea no formatea |
| ingra.iguales (r1, r2, dec=8) |
Son iguales los números reales a y b redondeados con dec decimales |
| ingra.ac (num, dec, presentaCero, omas) |
Convierte a cadena; presentaCero por defecto cadana vacia si 0; omas pone dec decimales o más |
| ingra.dc (a, dec) |
Convierte de cadena a número |
| ingra.ceros (n, t) |
Retorna cadena del número n añadiendo t ceros delante |
| ingra.aleatorio (n) |
Retorna numero aleatorio entre 0..n-1 |
| ingra.recta (x1, y1, x2, y2, x) |
Devuelve y para la abscisa x, que esté en la recta de los 4 primeros puntos (semajanza de triángulos de Tales). Admite (x1,y1,x) |
| ingra.entre (x1, x2, x, margen=0) |
¿Está x entre x1 y x2? (1)ok (null)exterior |
|
Básicos de Listas (L) |
| ingra.dl (ds, codo) |
De objeto {...} a lista [...] |
| ingra.ds (dl, cod, codo=null) |
De lista [...] a objeto {...}, cod: "a" o ["a",...], codo:dl[codo][cod](opcional) |
| ingra.cl (dl, cod, ordenada=false) |
De lista de objetos a lista de un campo (si ordenada implica única y sin nulos) |
| ingra.ao (o, ...vl) |
OBSOLETA usar objeto literal. De lista a objeto (cod,val, cod,val, ...) | (objeto, cod,val,...) | (objeto,objeto, cod,val,... ) |
| ingra.suma (dl, el) |
Suma vectores (vector_numérico) o (vector_objetos, campo[.campo]) o (vector_numerico, vector_numérico) o (vector_numerico, constante) |
| ingra.resta (dl, el) |
Resta vectores (vector_numerico, vector_numérico) o (vector_numerico, constante) |
|
Básicos de cadenas (S) |
| ingra.modo (texto, letra, noexiste, novalor, minimo, maximo) |
Analiza modo en cadena con formato: <modo=letra><valor=numero>..., noexiste:0,novalor:1 // noexiste:0,novalor:1 |
| ingra.modos (texto, defectos, conVectores) |
Analiza modos en cadena con formato: <modo=letra><valor=numero>... > {letra:numero | letra:[numero]} |
| ingra.modos2 (texto, defectos) |
Analiza modos en cadena con formato: <modo=letra><valor=numero>... > {letra:numero | letra:[numero]} |
| ingra.opcion (i, ...al) |
Devuelve índice base Opción |
| ingra.compara (a, b, descendente) |
Compara a > b ? 1 : a < b ? -1 : 0, si descendente al contrario |
|
Básicos de archivos (F) |
| ingra.preextension (arc, ponPreextension) |
Archivo con preextensión añadida (camino/nombre[preextensión].extension) |
| ingra.extension (arc, ponExtension) |
Extensión del archivo en minusculas y 3 letras; si ext retorna archivo con nueva extension |
| ingra.archivo (arc) |
Nombre del archivo arc con extensión |
| ingra.nombre (arc, conExtension) |
Nombre del archivo arc, por defecto sin extensión. conExtension==2 incluye camino1 |
| ingra.camino (arc) |
Camino del archivo arc |
|
Básicos de objetos (O) Tipos de datos |
| ingra.esN (o) |
Es Number (número real o entero), Number.isInteger(o) para enteros |
| ingra.esB (o) |
Es Bool (boleano) |
| ingra.esS (o) |
Es String |
| ingra.esF (o) |
Es Function |
| ingra.esA (o) |
Es Array |
| ingra.esD (o) |
Es Date |
| ingra.esR (o) |
Es RegExp (regular expresión) |
| ingra.esO (o) |
Es Object |
| ingra.cbDefecto (data) |
cb de defecto, si error presenta en consola |
| ingra.B |
Clase ArrayBuffer; representa un genérico buffer de datos binarios de longitud fija, no se puede manipular el contenido |
| ingra.B.deFile (file, cb, cbProgress) |
De File a ArrayBuffer; utiliza FileReader |
| ingra.B.deCanvas (canvas) |
De Canvas a Uint8ClampedArray; utiliza ImageData |
| ingra.B.deString (str) |
De cadena a buffer |
| ingra.B.deBase64 (base64) |
De base64 a buffer |
| ingra.B.deDataUrl (dataUrl) |
De dataURL "data:<mime>;base64,<base64>" a buffer |
| ingra.B.deBlob (blob, cb) |
De blob a buffer |
| ingra.B.aString (buf) |
A cadena |
| ingra.B.aBlob (buffer, type) |
A blob |
| ingra.B.aArray (typedArray) |
A array normal, = Array.from, constructor === Array, |
| ingra.B.aBase64 (buf) |
A base64 |
| ingra.B.get (url, cb) |
Recibe buffer de una URL |
| ingra.B.post (url, buffer, cb) |
Envia buffer a una URL; El metodo send() de las instancias XMLHttpRequest ahora admite vectores tipados y objetos ArrayBuffer como argumento. |
| ingra.B.dc (str) |
De cadena a buffer ; usa charCodeAt(16unicode) > Uint16Array |
| ingra.B.ac (buf) |
De buffer a cadena; Uint16Array > String.fromCharCode(16unicode) |
| ingra.B.ac16 (buf) |
De buffer a cadena; Uint16Array > String.fromCharCode(16unicode) |
| ingra.B.dc16 (str) |
De cadena a buffer ; usa charCodeAt(16unicode) > Uint16Array |
| ingra.B.igual (a, b) |
Compara buffers |
| ingra.blob |
Clase blob (Binary Large OBjects), representation de datos en bruto en disco Blob:{name,size,type,...}; file is a blob |
| ingra.blob.deBase64 (base64, mime) |
Convierte de base 64 |
| ingra.blob.deDataUrl (dataUrl) |
Convierte de data url > deBase64 |
| ingra.blob.deCanvas (canvas, cb, type, quality) |
De canvas type:"image/png"(/jpeg/webp); quality:0.95(0..1) > deDataUrl > (blob) |
| ingra.blob.deImage (image) |
De image |
| ingra.blob.deTexto (texto, mime) |
Convierte de texto; mime:'text/css'|'text/html'|... |
| ingra.blob.aImage (blob, image) |
Retorna image.src |
| ingra.blob.aDataUrl (blob) |
Añade un link desde blob |
| ingra.blob.aLink (div, blob) |
Añade un link desde blob |
| ingra.base64 |
Clase base64; base64 usa caracteres "A-Z", "a-z", "0-9", "+", "/" y "=" para codificar binarios |
| ingra.base64.dc (str) |
De cadena a base64 == window.atob |
| ingra.base64.ac (b64) |
De base64 a cadena == window.btoa |
| ingra.dataUrl |
Clase dataUrl |
| ingra.dataUrl.deTexto (texto, type='text/plain') |
De texto > dataUrl |
| ingra.dataUrl.deBlob (blob, cb) |
De blob|file > ({dataUrl}) |
| ingra.dataUrl.deUrl (url, cb) |
De url > {dataUrl} |
| ingra.dataUrl.deImg (img, op) |
De imagen op:{formato:jpg*|jpeg|png|webp, calidad:0.85, alto[Mm], ancho[Mm], maximo[Mm]} > canvas > {ancho[Mm],alto[Mm],dataUrl} |
| ingra.dataUrl.deImgSrc (src, op, cb) |
De imagen (source) op:{formato:jpg*|jpeg|png|webp, calidad:0.85, alto[Mm], ancho[Mm], maximo[Mm]} > Image load > deImg |
| ingra.D |
Clase date. Generales de tiempo, fecha y hora |
| ingra.D.fec (d) |
De date a fecha (aaaammdd) |
| ingra.D.hor (d) |
De date a hora (hhmmss) |
| ingra.D.fechor (d) |
De date a fechahora (aaaammdd.hhmmss) |
| ingra.D.diaSemana (d) |
De date a día de la semana (0)lunes (1)martes ... (7)domingo |
| ingra.D.ao (d) |
De date a objeto >{a,m,d,h,mi,s, ms} |
| ingra.D.id2 (d, sep='.', conMs) |
De date a formato: aaaammdd.hhmmss[ii]; con milisegundos |
| ingra.D.id3 (d, sep='.') |
De date a formato: aaaammdd.hhmmssii |
| ingra.D.ac (d) |
De date a formato: "d/m/a h:m:s" |
| ingra.D.forma (d, frm) |
De date a formato frm: aaaa(2020) | aa(20) | mmmm(Marzo) | mmm(Mar) | mm(03) | dddd(Martes) | ddd(Mar) | dd(11) | hh(12) | mm(18) | ss(32) // Ejemplo:" dddd, d de mmmm de aaaa" |
| ingra.D.amd (d) |
De date a formato "aaaa-mm-dd" |
| ingra.D.amd2 (d) |
De date a formato "aaaammdd-hhmmssii" (ISO: aaaa-mm-ddThh:mm:ss.iiiZ 2012-11-30T01:21:00.000Z)" |
| ingra.D.aFH (d) |
De Date a fecha y hora > [fec,hor] |
|
A date |
| ingra.D.dc (a) |
A date desde formato "d/m/a h:m:s" con cualquier separador |
| ingra.D.pon (a, b) |
A date desde (fec,hor) | (fechor) | (Date) | (año, mes, día, horas, minutos, segundos, milisegundos) | (milliseconds) | (isodate String) |
| ingra.D.deFH (fec, hor) |
A date desde fecha y hora; admite (fec,hor) o (fechor) |
| ingra.D.deAMDHMS (ano, mes, dia, hrs, min, seg, ms) |
A date desde AMDHMS |
| ingra.D.deDMAHMS (dia, mes, ano, hrs, min, seg, ms) |
A date desde DMAHMS |
|
Varios |
| ingra.D.ms2a (ms) |
De milisegundos a cadena "HHhMMmSSsIIIms" |
| ingra.D.cuantasVeces (tiempo, funcion) |
Cuenta veces se ejecuta 'funcion' en 'tiempo' |
| ingra.D.cuantoTiempo (funcion) |
Cuenta tiempo (ms) tarda 'funcion' en ejecutarse |
| ingra.fec |
Clase fecha entero con formato AAAAMMDD |
| ingra.fec.pon (d, m, a, noAdmiteIncompleta) |
Retorna fecha desde (d,m,a) o (Date) o {d,m,a} o (fec) o (a,m,d); |
| ingra.fec.completa (fec) |
Retorna fecha completa; debe incluir d,m,a |
| ingra.fec.actual () |
Retorna fecha actual |
| ingra.fec.mesAnterior () |
Primer día del mes anterior |
| ingra.fec.dia (fec, dia) |
Dias de fec (0..31). Si dia retorna fec con dia |
| ingra.fec.mes (fec, mes) |
Mes de fec (0..12). Si mes retorna fec con mes |
| ingra.fec.ano (fec, ano) |
Año de fec (aaaa). Si ano retorna fec con año |
| ingra.fec.mesNombre (fec) |
Nombre del mes de fec (Enero,..) |
| ingra.fec.diaNombre (fec) |
Nombre del mdía de fec (Lunes,...) |
| ingra.fec.aDate (fec) |
De fec a Date |
| ingra.fec.agrega (fec, d, m, a) |
Agrega d(dias) m(meses) a(anos) a fec, d,m,a pueden ser negativos; fec opcional (defecto hoy) |
| ingra.fec.semanaAno (fec) |
Nº de semana en el año 1..52 + restos(0,53) |
| ingra.fec.semanaAnoBuffer (fec, buffer) |
Nº semana en el año (con buffer para llamadas repetidas) 0..51 (restos a 0 y 51) |
| ingra.fec.diaSemana (fec, comoTexto) |
Retorna nombre del día de la semana con 0:LUNES. Admite param. (d,m,a) |
| ingra.fec.diaSemana1 (sem, ano) |
Retorna nombre de primer dia de la semana sem |
| diasMes1 |
Días del año al comienzo de cada mes (no bisiestos) |
| diasMes2 |
Días de cada mes (año no bisiesto) |
| diasMes2.bisiesto (ano) |
Retorna true|false |
| diasMes2.diasAno (ano) |
Días del año (365 o 366 bisiestos) (ano) o (fec) > nºdias |
| diasMes2.diasMes (mes, ano) |
Días del mes. También admite sólo un param (fec) - fecmesdia |
| diasMes2.diasHasta (fec) |
Número de dias del año - fecanodia |
| diasMes2.mesesEntre (f1, f2) |
Nº de meses entre fechas |
| diasMes2.diasEntre (f1, f2) |
Nº de días entre fechas |
| diasMes2.anos (fec) |
Fecha en años en decimal |
| diasMes2.nombre (fec, breve) |
Formato como '12 Agosto 2009' o 'Ago 2008', incompletas por la izquierda - fec2nom |
| diasMes2.forma (fec, f) |
Formato (admite varios) f: aaaa|mmmm|mmm|mm|dddd|ddd|dd|hh|nn|ss|a - fec2forma |
| diasMes2.ao (fec) |
De fecha a objeto, aaaammdd > {a,m,d} |
| diasMes2.do (o) |
De objeto a fecha, {a,m,d} > aaaammdd |
| diasMes2./*ac (fec, sep='/', conceros=1, diaSemana=0) |
Formato a cadena sep='/', conceros:1, diaSemana:0,1,2,3,-1 |
| diasMes2.ac (fec, op) |
Formato a cadena, op:sep|{sep:'/', conceros:1, diaSemana, sinhoy, concolor, defecto}, (diaSemana>0)nºcaracteres |
| diasMes2.dc (a, noAdmiteIncompleta) |
Formato de cadena - str2fec |
| ingra.hor |
Clase hora entero con formato HHMMSS |
| ingra.hor.pon (h, m, s, esIntervalo) |
Retorna hor, admite Date; h,m,s; si !intervalo h:0..24 |
| ingra.hor.actual () |
Retorna hor actual |
| ingra.hor.seg (hor, s) |
Segundos de 'hor'. Con s(segundos) retorna hor con s incluidos |
| ingra.hor.min (hor, m) |
Minutos de 'hor'. Con m(minutos) retorna hor con m incluidos |
| ingra.hor.hrs (hor, h) |
Horas de 'hor'. Con h(horas) retorna hor con h incluidas |
| ingra.hor.entre (hor1, hor2) |
retorna hora entre dos horas |
| ingra.hor.media (hor1, hor2) |
retorna hora media entre dos horas |
| ingra.hor.agrega (hor, h, m, s) |
Agrega a hor h(horas), m(minutos) y s(segundos)) |
| ingra.hor.aHoras (hor) |
De hor a horas decimales |
| ingra.hor.deHoras (horas) |
De horas decimale a hor |
| ingra.hor.ao (hor) |
De hor a objeto {h,m,s} |
| ingra.hor.ac (hor, sep=':', def=[2, 2, 2], esPeriodo) |
Retorna cadena hh:mm:ss; def dígitos en h,m,s; si esPeriodo retorna h:m:s |
| ingra.hor.dc (a) |
Retorna hor desde cadena; trocea cadena con cualquier separador no numérico; '.' hora actual |
| ingra.fechor |
Clase número real en formato aaammdd.hhmmss |
| ingra.fechor.actual () |
Retorna fh actual |
| ingra.fechor.forma (fh) |
Retorna fh desde number, string, date o array |
| ingra.fechor.pon (dia, mes, ano, hrs, min, seg, noAdmiteIncompleta) |
Retorna fh; admite (fec,hor), (ano,mes,dia) |
| ingra.fechor.agrega (fec, d, m, a, h, mi, s) |
Agrega d(dias) m(meses) a(anos) a fec, d,m,a pueden ser negativos; fec opcional (defecto hoy) |
| ingra.fechor.aFH (fh) |
Retorna [fec,hor] de fh |
| ingra.fechor.deFH (f, h) |
Retorna fh desde [fec,hor] |
| ingra.fechor.aDate (fh) |
Retorna Date |
| ingra.fechor.deDate (d) |
Retorna fh desde Date |
| ingra.fechor.aJSON (fh) |
Retorna formato ISO: 2013-04-14T18:26:46.613Z |
| ingra.fechor.fec (fh) |
Retorna la fecha de fh |
| ingra.fechor.hor (fh) |
Retorna la hora de fh |
| ingra.fechor.hrs (fh) |
Retorna las horas decimales de fh |
| ingra.fechor.ao (fh) |
Retorna objeto > {a,m,d,h,mi,s} |
| ingra.fechor.ac (fh, op) |
Retorna "d/m/a h:m:s"; con número de dígitos, op:{sep:'/', conceros:1, diaSemana, sinhoy, concolor}, (diaSemana>0)nºcaracteres |
| ingra.fechor.dc (a) |
De cadena "d/m/a h:m:s" a fh; admite cualquier separador; '.' o '/' retorna actual; admite ISO |
| ingra.fechor.diferencia (fh1, fh2) |
Retorna diferencia entre fhs en horas decimales |
| ingra.diames |
Clase número entero en formato mmdd |
| ingra.diames.pon (d, m) |
Retorna dm |
| ingra.diames.actual () |
Retorna dm actual |
| ingra.diames.agrega (dm, d, m) |
Retorna dm incrementado en d(dias), m(meses) |
| ingra.diames.ac (dm, sep='/', num=2) |
Retorna "dd/mm"; num(número de cifras) |
| ingra.diames.dc (a) |
Retorna fh de cadena "d/m" con cualquier separador; '.' retorna fh actual |
| ingra.mesano |
Clase número entero en formato aaaamm |
| ingra.mesano.pon (m, a) |
Retorna ma |
| ingra.mesano.actual () |
Retorna ma actual |
| ingra.mesano.agrega (ma, m, a) |
Retorna ma incrementado en m(meses) a(años) |
| ingra.mesano.dentro (fec, md1, md2) |
fec está entre md1 y md2 |
| ingra.mesano.ao (ma) |
Retorna objeto {a,m} |
| ingra.mesano.ac (ma, alfa) |
Retorna "mm/aaaa"; alfa: "nombresMes aaaa" |
| ingra.mesano.dc (s) |
Retorna ma de cadena "m/a" con cualquier separador; '.' retorna ma actual |
Lee archivo local // Presenta diálogo del sistema operativo - file:{ name:"a.png", size:47744, type:"image/png", lastModifiedDate }
| ingra.F.lee (op, cb) |
Lee archivo local como texto UTF8, op:{cbProgress} > (data,file,ev) |
| ingra.F.leeAnsi (op, cb) |
Lee archivo local como texto ANSI, op:{cbProgress} > (data,file,ev) |
| ingra.F.leeJson (op, cb) |
Lee archivo local como JSON, op:{cbProgress} > (objJs,file,ev) |
| ingra.F.leeDataUrl (op, cb) |
Lee archivo local como DataUrl, op:{cbProgress} > (dataUrl,file,ev) |
| ingra.F.leeBuffer (op, cb) |
Lee archivo local como Buffer, op:{cbProgress} > (buffer,file,ev) |
|
Graba archivo local // Presenta diálogo del sistema operativo |
| ingra.F.graba (name, texto) |
Graba archivo de texto utf8 |
| ingra.F.grabaAnsi (name, texto) |
Graba archivo de texto ansi |
| ingra.F.grabaBinario (name, data) |
Graba archivo binario |
| ingra.F.grabaCanvas (name, canvas, quality) |
Graba archivo con el contenido de un objeto canvas |
| ingra.F.descarga (url, name, forzada) |
Descarga contenido de la url al archivo local name, si no forzada el navegador decide que hacer con los datos a descargar |
|
Graba archivo remoto // XMLHttpRequest POST |
| ingra.F.sendData (data, url, cb) |
Envia data a url; XMLHttpRequest POST |
| ingra.F.sendFile (file, url, cb) |
Envia file a url |
| ingra.F.sendCanvas (canvas, url, cb, tipo, calidad) |
Envia canvas a url; canvas.toDataURL sendData; tipo:png|jpeg|webp; calidad:De jpg |
| ingra.L |
Listas de objetos |
| ingra.L.compara (a, b, orden) |
Compara objetos, retorna 1(a>b),0(a=b),-1(a<b), null ~ 0 a todos los efectos en comparaciones |
| ingra.L.ordena (ol, orden) |
Ordena lista de objetos sobre si misma |
| ingra.L.buscai (ol, campos) |
Busca en lista de objetos el primero que cumple el criterio de campos, retorna -1 o posición en base 0 |
| ingra.L.buscail (ol, campos) |
Busca en lista de objetos los que cumplen el criterio de campos, retorna lista de posiciones |
| ingra.L.busca (ol, campos) |
Busca en lista de objetos el primero que cumple el criterio de campos, retorna el objeto o null |
| ingra.L.buscal (ol, campos) |
Busca en lista de objetos los que cumplen el criterio de campos, retorna lista de objetos o [] |
| ingra.L.cuenta (ol, campos) |
Cuenta en lista de objetos los que cumplan el criterio de campos, retorna número de encontrados |
| ingra.L.elimina (ol, campos) |
Elimina los objetos de la lista que cumplan el criterio de campos, retorna número de eliminados |
| ingra.L.buscaObjeto (ol, o) |
Busca objeto en lista de objetos, retorna -1 o posición del objeto encontrado en base 0 |
| ingra.L.eliminaObjeto (ol, o) |
Elimina objeto en lista de objetos, retorna -1 o posición del objeto eliminado en base 0 |
| ingra.L.iniciaCeros (nh, nv) |
Crea una lista o una matriz rellena de 0s; (nh,nv=0) > nl | nll |
| ingra.L.agregaSumas (nll, mh, mv) |
Agrega filas y columnas con el total; (mh=0,mv=0) > nll:[nl+1]+n |
| ingra.M (function() |
librería de matemáticas retorna el objeto M con toda las functiones -1-Revision |
| M.rad (gra) |
De grados a radianes |
| M.gra (rad) |
De radianes a grados |
| M.tan2 (rad) |
Contraria a atan2(y,x), retorna {x,y} |
| M.igual (n1, n2, mar) |
Comprueba que son iguales 2 numeros |
| M.igual0 (n, mar) |
Comprueba si n es = 0 |
| M.fraccion (n) |
Retorna la parte decimal del numero |
|
operaciones sobre listas numéricas |
| M.max (nl, cod) |
Retorna el valor máximo valor de nl (con parámetro opcional 'cod', retorna el máximo de nl[][cod]) // sin 'cod' equivale a Math.max(...nl) |
| M.min (nl, cod) |
Retorna el valor mínimo valor de nl (con parámetro opcional 'cod', retorna el mínimo de nl[][cod]) // sin 'cod' equivale a Math.min(...nl) |
| M.sum (nl, cod) |
Retorna la suma de valores de nl (con parámetro opcional 'cod', retorna la suma de nl[][cod]) |
| M.med (nl, cod) |
Retorna la media de valores de nl (con parámetro opcional 'cod', retorna la media de nl[][cod]) |
| M.dev (nl, cod) |
Retorna la desviación típica de nl (con parámetro opcional 'cod', retorna la desviación típica de nl[][cod]) |
| M.analiza (nl, cod) |
Retorna {min,max,sum,med,des} de (nl,cod) |
| M.unicos (ol, cod) |
Ordena y elimina duplicados (opcionalmente cod) |
|
operaciones sobre listas con índices |
| M.eliminaIndices (nl, il) |
Elimina elementos de nl en il(índices a nl), elimina en orden decreciente para no modificar los índices |
| M.mueveIndices (nl, i1, i2) |
Mueve elemento en i1(índice a nl) detrás de i2(índice a nl) en dirección i1-i2 |
| M.mueveIndicesDelante (nl, il, i2) |
Mueve elemento en i1(índice a nl) delante de i2(índice a nl); i1 puede ser una lista de índices; retorna i2 modificado |
| M.formatBytes (valor) |
Retorna valor con dos dígitos significativos en Bytes|KB|MB|GB|TB |
| M.aleatorio (min, max) |
Retorna un número aleatorio entero: (min,max) entre min incluido a max excluido // o (numero) desde 0 a numero no incluido |
| M.aleatorioN (N) |
Retorna un número aleatorio entero de N cifras; Math.pow(10,5) == 1e5 == 100.000 |
| M.aleatorioC (N) |
Retorna una cadena de N carácteres aleatorios entre [A,Z] |
| M.transpuesta (all) |
Retorna la matriz traspuesta solo 2d |
| M.determinante (all) |
Retorna determinante a[3][3] |
| ingra.bit (v, bit, pone) |
Operaciones de bits (v)indice (v,bit)valor (v,bit,0)pone0 (v,bit,1)pone1 (v,bit,-1)cambia bit |
| ingra.bit2l (val, length=8) |
De valor en bits a lista de 1|undefined |
| ingra.S |
Manipulación de cadenas de texto |
| ingra.S.simple (a) |
Elimina blancos por delante y por detrás y duplicados |
| ingra.S.troceaComillas (texto, mantieneComillas) |
Trocea cadena por espacios externos a '' "" / / [] () |
| ingra.S.troceaExterno (condicion, sep) |
Trocea cadena por espacios externos a '' "" / / [] () |
| ingra.S.izquierda (a, sep, porDetras) |
Retorna la cadena izquierda desde el primer separador. Sin separador, retorna todo. Si porDetras retorna desde el último separador. Sin separador retorna '' |
| ingra.S.derecha (a, sep, porDetras) |
Retorna la cadena derecha desde el primer separador. Sin separador, retorna ''. Si porDetras retorna desde el último separador. Sin separador retorna todo |
| ingra.S.split2 (a, sep, pordetras, conrecorte=1) |
Retorna lista [anterior,posterior] desde el primer separador 'sep' buscado desde el inicio o si pordetras desde el final |
| ingra.S.sinComillas (a) |
Recorta y elimina comillas " o ' si delante y detrás |
| ingra.S.eliminaLineasBlancas (a) |
Aplica expresión regular |
| ingra.S.eliminaComentarios (a, noLineComment) |
Elimina texto entre marcas /*...*/, si noLineComment, elimina comentarios simples javascript |
| ingra.S.esNombreArchivoValido (fname) |
¿Tiene caracteres válidos para file windows? |
| ingra.S.nombreArchivoValido (nom) |
Elimina caracteres \ / : * ? " < > | |
| ingra.S.codigoValido (cod, noInicial) |
Código para JS, file, mongoDb, reemplaza con _ caracteres \s\/:*?"<>\ noInicial comprueba que no empiece con número |
| ingra.S.esCodigoValido (cod, noInicial) |
¿Tiene caracteres válidos para mongoDb? |
| ingra.S.siguiente (s) |
Devuelve siguiente al nº de la serie, si no acaba en número, añade sufijo "0001" |
| ingra.S.anterior (s) |
Devuelve anterior al nº de la serie, si cero o menor, devuelve negativo con el mismo nº de caracteres (A000 > A0-1) |
| ingra.S.esCodigoMongo (a) |
Retorna false si contiene |/\. "$*<>:?ñ |
| ingra.S.esCodigo (a) |
Retorna false si contiene A-Z |
| ingra.S.esNumero (a) |
Retorna false si contiene distinto a 0-9 + - . , e E (- último sino \-) |
| ingra.S.esEntero (a) |
Retorna false si contiene distinto a 0-9 + - (- último sino \-) |
| ingra.S.esAlfanumerico (a) |
Retorna false si contiene distinto a a-z A-Z 0-9 _ |
| ingra.S.esAlfa (a) |
Retorna false si contiene distinto a a-z A-Z y espacio en blanco |
| ingra.S.utf2ansi (s) |
Cambio juego de caracteres |
| ingra.S.ansi2utf (s) |
Cambio juego de caracteres |
| ingra.file |
Clase file(blob); Formato para manejar objetos binarios, utilizado lara leer/grabar archivos del sistema operativo // { name:"a.png", size:47744, type:"image/png", lastModifiedDate } |
| ingra.file.aTexto (file, op, cb) |
De file a texto; {cbProgress,ev,ansi} > (textoUtf,file,ev) |
| ingra.file.aJson (file, op, cb) |
De file a JSON; {cbProgress,ev} > (objJs,file,ev) |
| ingra.file.aDataUrl (file, op, cb) |
De file a DataURL; {cbProgress,ev} > (dataUrl,file,ev) |
| ingra.file.aBuffer (file, op, cb) |
De file a Buffec; {cbProgress,ev}> (buffer,file,ev) |
| ingra.file.inputFile (op, cb) |
{soloImagenes} > (file,ev) // incluye file.ev, y file.url si ext=="url" multiple accept="image/*" |
| ingra.file.inputFiles (op, cb) |
{soloImagenes} > (files,ev) // files pueden incluir url |
| ingra.file.dragDataUrl (obj, cb) |
> (dataUrl,file,ev) |
| ingra.file.leeArchivo (...a) |
Obsoleto > ingra.F.lee |
| ingra.file.leeArchivoJson (...a) |
Obsoleto > ingra.F.leeJson |
| ingra.file.leeArchivoDataURL (...a) |
Obsoleto > ingra.F.leeDataUrl |
| ingra.file.leeArchivoBuffer (...a) |
Obsoleto > ingra.F.leeBuffer |
| ingra.file.grabaArchivo (...a) |
Obsoleto > ingra.F.graba |
| ingra.color |
Objeto color {r,g,b,[a]} 0-255 0-1 defecto(0,0,0,undefined) |
| ingra.color.dc (s) |
De Cadena a color, < 0xRRGGBB | {r,g,b,a} | r,g,b,[a] | [r,g,b,[a]] | "[#]rrggbb" | "[#]rgb" |
| ingra.color.ac (c, s, conalfa) |
De Color a cadena; s(separador=',') > RsGsB[sA] |
| ingra.color.pon (s) |
Define color |
| ingra.color.x6 (c, sinAbreviar) |
De color a CSS "#rrggbb" || "#rgb" |
| ingra.color.x8 (c, sinAbreviar) |
De color a !CSS "#rrggbbaa" "#rgba" |
| ingra.color.rgbf (c) |
de color a CSS "rgb(r,g,b)" |
| ingra.color.rgbaf (c) |
De color a CSS "rgba(r,g,b,a)" |
| ingra.color.css (c, sinAbreviar, sinTransparencia) |
De color a CSS "rgba(r,g,b,a)" || "#rrggbb" | "#rgb" comprueba c |
| ingra.color.css4 (c, sinAbreviar) |
De color a #rrggbbaa |
| ingra.color.transparencia (c, tra) |
Pone transparencia número |
| ingra.color.gris (c) |
A gris, (0.299 * r + 0.587 * g + 0.114 * b) |
| ingra.color.claro (c, n, encss) |
Aclara color, n:(0)c (0.5)defecto (1)blanco |
| ingra.color.oscuro (c, n, encss) |
Oscurece color, n:(0)c (0.5)defecto (1)negro |
| ingra.color.medio (c1, c2, n) |
Color medio; n:(0)c1 (0.5)defecto (1)c2 |
| ingra.color.aHSL (col) |
De color RGB a HSL; {r,g,b} > {h,s,l} |
| ingra.color.deHSL (hsl, col) |
De color HSL a RGB; {h,s,l} > {r,g,b} |
| ingra.color.ponH (color, hue) |
Pon Hue a color (Tono o Matiz), hue:0-360, (0)rojo (60)amarillo (120)verde (180)cian (240)azul (300)magenta |
| ingra.color.ponS (color, sat, porcentaje) |
Pon Saturation (Saturación) a color, sat:0(gris)-100(color) o procentaje<100 oscurece |
| ingra.color.ponL (color, lum, porcentaje) |
Pon Lumninance (Luminosidad) a color, lum:0(negro)-100(blanco) o procentaje<100 oscurece |
| ingra.color.serie (col1, col2, numero, desplaza) |
A serie entre col1 y col2 de numero de colores; desplaza opcional |
| ingra.imagen |
Utilidades de imagen |
|
Filtros |
| ingra.imagen.filtroGrises (canvas, modo) |
Aplica modo: (0*)media:(r+g+b)/3 o (1)brillo:0.2126*r + 0.7152*g + 0.0722*b |
| ingra.imagen.filtroBlancoNegro (canvas, modo) |
Aplica modo: (0*)media=(r+g+b)/3 o (1)brillo:0.2126*r + 0.7152*g + 0.0722*b >128? 255: 0 |
| ingra.imagen.filtroPosteriza (canvas, nivel=2) |
Aplica posterización nivel:2..255 (2)8 (3)27 (4)64 ... |
| ingra.imagen.filtroBrillo (canvas, reduce=0) |
Amplia o reduce el brillo de la imagen |
| ingra.imagen.filtroInvierte (canvas) |
Invierte 3 componentes (no incluye transparencia) r,g,b > 255-r,g,b |
| ingra.imagen.filtroSepia (canvas) |
Modifica r,g,b > r*[.393,.769,.189], g*[.349,.686,.168] b*[.272,.534,.131] |
| ingra.imagen.filtroContraste (canvas, contraste=50) |
Cambia contraste -255..255 |
| ingra.imagen.filtroEspejo (canvas, vertical) |
Aplica espejo horizontal, si vertical espejo vertical (flip) |
|
Operaciones |
| ingra.imagen.cambiaColor (canvas, c1, c2, margen=0) |
Cambia color c1 por c2, no modifica alfa c1,c2:{r,g,b} |
| ingra.imagen.grabaCanvas (canvas, arc) |
Diálogo graba archivo con el contenido del canvas; jpg png webp |
| ingra.imagen.url2canvas (url, cb) |
Carga imagen, crea canvas del mismo tamaño y dibuja imagen en canvas. > (canvas) url2image createElement drawImage |
| ingra.imagen.url2image (url, cb) |
Carga imagen, > (image) onload |
| ingra.csv |
Utilidades para formato CSV
{titulo"", campos[{}], lineas[][], estadistica{}} |
| ingra.csv.estadistica (csv, numeroValoreMaxmo=8) |
Estadística del contenido de un objeto CSV({campos[{}], lineas[[]], titulo})
> estadistica:[codigoCampo:valor[repeticiones]...resto[]] |
| ingra.csv.lis2tip (ol, cam) |
analiza tipo de un campo(código) en lista de objetos ol:[{}] |
| ingra.tex2csv (texto, op) |
De texto(contenido archivo CSV) a objeto CSV
op:{lintit=0, lincam=0, sinCamposVacios=0, sinLineasVacias=1, conCampos=0, conEstadistica=0} lintit:Línea con título; lincam:Línea con campos
texto|lineas > {titulo"", campos[{}], lineas[][], estadistica{}} |
| ingra.docl2csv (docl, _caml) |
Retorna {campos,lineas} con campo:{cod,num,tip} |
| ingra.csv2tex (csv, ) |
De objeto CSV a texto CSV
csv:{titulo"", campos[{cod}|cod], docl[{}]|lineas[][]}, op:{sep:';',bom}
Envuelve con " los datos que incluyen separadores o comillas
formato estándar: separador ',' y juego de caracteres ANSI
formato Excel: separador ';' y BOM al comienzo del archivo para detectar utf8 |
| ingra.csv2docl (csv) |
Retorna lista de documentos docl, cada uno una línea del csv |
| ingra.csv2table (csv, op) |
Retorna cadena en formato html "<table>...</table>" - {clase,numeros} |
| ingra.csv2html (csv, op=) |
Retorna cadena en formato html "<table>...</table>" - {clase,numeros} |
| ingra.csv |
Utilidades para formato CSV {titulo"", campos[{}], lineas[][], estadistica{}} |
| ingra.csv.tex2csv (tex, op) |
De texto(contenido archivo CSV) a objeto CSV // op:{lintit=0, lincam=0, lindat=1, sinCamposVacios=0, sinLineasVacias=1, conCampos=0, conEstadistica=0} lintit:Línea con título; lincam:Línea con campos; lindat:Primera línea con datos; en base 1/ // > {titulo"", campos[{}], lineas[][], estadistica{}} |
| ingra.csv.csv2tex (csv, op) |
De objeto CSV a texto CSV // csv:{titulo"", campos[{cod}|cod], docl[{}]|lineas[][]}, op:{sep:';',bom}; envuelve con " los datos que incluyen separadores o comillas |
| ingra.csv.estadistica (csv) |
Estadística del contenido de un objeto CSV({campos[{}], lineas[[]], titulo}) // > estadistica:[codigoCampo:valor[repeticiones]...resto[]] |
| ingra.csv.lis2tip (ol, cam) |
analiza tipo de un campo(código) en lista de objetos ol:[{}] |
| ingra.docl2csv (docl) |
Retorna {campos,lineas} con campo:{cod,num,tip} |
| ingra.csv2table (csv, op) |
Retorna cadena en formato html "<table>...</table>" - {clase,numeros} |
| ingra.pun |
Librería de geometría: Puntos (punto: {x,y,...}) |
| ingra.pun.copia (...p) |
Copia desde formatos: (x,y) ([x,y]) ({x,y,...}) ({lon,lat}) ({lng,lat}) (number) |
| ingra.pun.forma (...p) |
Copia si no tiene formato punto |
| ingra.pun.dc (a, sep=';') |
De cadena a punto |
| ingra.pun.ac (p, dec, sep='; ') |
De punto a cadena |
|
Retorna el mismo punto |
| ingra.pun.red1 (p, dec=0) |
Redondea con 'dec', modifica y retorna p |
| ingra.pun.suma1 (p, p2) |
Suma p más p2, modifica y retorna p |
| ingra.pun.resta1 (p, p2) |
Resta p menos p2, modifica y retorna p |
| ingra.pun.mul1 (p, fac) |
Multiplica p por fac, modifica y retorna p |
| ingra.pun.div1 (p, fac) |
Divide p por fac, modifica y retorna p |
|
Retorna pun |
| ingra.pun.red (p, dec=0) |
Retorna p redondeado con 'dec' decimales |
| ingra.pun.suma (p, p2) |
Suma p más p2 (sinónimo: sum) |
| ingra.pun.resta (p, p2) |
Resta p menos p2 (sinónimo: res) |
| ingra.pun.mul (p, fac) |
Multiplica p por fac |
| ingra.pun.div (p, fac) |
Divide p por fac |
| ingra.pun.medio (a, b) |
Punto medio entre 'a' y 'b' (sinónimo: med) |
| ingra.pun.tamano (a, b, abs) |
el tamaño o diferencia entre 'a' y 'b' (sinónimo: tam) |
| ingra.pun.recta (a, b, p) |
Retorna punto de forma: 'a' es a 'b' como 'p' es a punto |
| ingra.pun.perpendicular (a, b, p, soloEntre) |
Retorna punto intersección de la línea formada por 'a' y 'b' y su perpendicular por 'p' |
| ingra.pun.afactor (a, b, factor) |
Retorna punto a distancia(factor: 0 a 1 b) de punto a en dirección a punto b |
| ingra.pun.afactorP (a, b, factor) |
Retorna punto a distancia(factor: 0 a 1 b) de a en dirección perpendicular a a-b |
| ingra.pun.adistancia (a, b, distancia) |
Retorna punto a distancia de punto a en dirección a punto b |
| ingra.pun.adistanciaP (a, b, distancia) |
Retorna punto a distancia de punto a en dirección perpendicular a a-b |
| ingra.pun.incentro (a, b, c) |
Retorna punto de corte de las bisectrices de un triangulo (a,b,c) |
| ingra.pun.interseccion (a, b, c, d, soloEntre) |
Retorna punto interseción entre linea a-b y linea c-d, si soloEntre retorna null si intersección fuera de segmentos |
|
Retorna rectángulo (rec) |
| ingra.pun.rec (a, b, margen) |
Retorna rectángulo {x1,y1,x2,y2} con margen opcional |
|
Retorna lista de puntos (punl) |
| ingra.pun.punl4 (a, b) |
Retorna los cuatro puntos del rectángulo |
| ingra.pun.margen4 (a, b, margen) |
Retorna los cuatro puntos de la línea con margen, también admite un solo punto |
| ingra.pun.mueveOrtogonal (p0, p) |
Retorna p ortogonal a p0 |
|
retorna valor |
| ingra.pun.igualE (a, b, margen=Number.EPSILON) |
Es igual o menor a EPSILON la distancia entre a y b |
| ingra.pun.igual (a, b, margen) |
Es igual o menor a margen la distancia entre a y b |
| ingra.pun.dis2 (a, b) |
Distancia al cuadrado entre a y b |
| ingra.pun.dis (a, b) |
Distancia entre a y b |
| ingra.pun.area (a, b) |
Área del rectángulo formado por a y b |
| ingra.pun.sin (a, b) |
Retorna el seno del ángulo entre dos puntos (versor) |
| ingra.pun.cos (a, b) |
Retorna el coseno del ángulo entre dos puntos (versor) |
| ingra.pun.tan (a, b) |
Retorna la tangente del ángulo entre dos puntos (sin/cos) |
| ingra.pun.ang (a, b, c) |
Retorna el ángulo (radianes) entre dos o tres puntos 0-360? |
| ingra.pun.alaDerecha (a, b, c) |
¿Está c a la derecha de la línea a-b? |
| ingra.pun.alaDerecha2 (a, b, c, d) |
¿Está d a la derecha de la línea a-b y de la línea b-c? |
| ingra.pun.intersecta (a, b, c, d) |
¿Intersecta el segmento a-b con el c-d? |
| ingra.pun.modulo (a) |
Módulo de a SQRT(a.x**2 +a.y**2) |
| ingra.pun.cross (a, b, co) |
Producto vectorial o producto cruz (cross) a.x * b.y + a.y * b.x; |
| ingra.pun.dot (a, b, co) |
Producto escalar o producto punto, dot(a,b) = a.x * b.x + a.y * b.y = |a|*|b|*cos(ab) |
| ingra.punl |
Librería de geometría: Lista de puntos (punl:{pun,...}, pun:{x,y,...}) |
| ingra.punl.copia (arg) |
Copia desde formatos: (x,y,...) ({x,y},...) ([x,y],...) ([x,y,...]) ([{x,y},...]) ([[x,y],...]) ({x1,y1,x2,y2}) ({left,bottom,right,top}) |
| ingra.punl.forma (arg) |
Copia si no tiene formato lista de puntos |
| ingra.punl.dc (a, sep) |
Convertir de cadena |
| ingra.punl.ac (pl, dec, sep) |
Convertir a cadena |
| ingra.punl.acr (pl, dec, sep) |
Convertir todos los puntos relativos al primero |
| ingra.punl.al (pl) |
Convertir a lista |
| ingra.punl.all (pl) |
Convertir a lista de listas |
|
retorna this |
| ingra.punl.red1 (pl, dec=0) |
Redondeado al decimal dec |
| ingra.punl.mas1 (pl, p) |
Suma p a todos los puntos de pl |
| ingra.punl.men1 (pl, p) |
Resta p a todos los puntos de pl |
| ingra.punl.por1 (pl, fac) |
Multiplica a todos los puntos de pl por fac |
|
retorna PUNL |
| ingra.punl.red (pl, dec=0) |
Redondeado |
| ingra.punl.mas (pl, p) |
Suma p a todos los puntos de pl |
| ingra.punl.men (pl, p) |
Resta p a todos los puntos de pl |
| ingra.punl.por (pl, fac) |
Multiplica a todos los puntos de pl por fac |
| ingra.punl.regular (o) |
Crea el poligono regular {x,y,r,n, a=90,r2=r} o {pun,rad,num,ang,rad2} // puntoCentral, númeroVerticas anguloInicial radios |
| ingra.punl.estrella () |
Crea una estrella de n lados |
| ingra.punl.flor () |
Crea una flor de n lados |
| ingra.punl.simplifica (pl, margen, altaCalidad) |
Elimina puntos colindantes mas cercanos que margen (en pixel margen=1) |
| ingra.punl.punto (pl, cerrado, i) |
Punto i de la lista de puntos, cíclico, puede ser < 0 y >= pl.length o null si no cerrado |
| ingra.punl.puntos (pl, cerrado, i1, i2) |
Puntos desde i1 a i2 incluidos, de la lista de puntos, cíclico, pueden ser < 0 y >= pl.length o null si no cerrado |
| ingra.punl.limite (pl) |
Retorna el rectangulo no inclinado mínimo que contiene a pl |
|
Retorna PUN |
| ingra.punl.centro (pl) |
De límite (antes medio) |
| ingra.punl.medio (pl) |
Medio (antes centro) |
| ingra.punl.centroide (pl) |
Centroide == centro de masa (densidad uniforme) == centro de gravedad SUM(a*x)/SUM(a) |
|
Retorna valor |
| ingra.punl.area (pl) |
Área (positivo en sentido agujas reloj) |
| ingra.punl.perimetro (pl, cerrado) |
Perímetro. Si cerrado, une último con primero |
| ingra.punl.dentro (pl, pun) |
Comprueba si pun está dentro de pl |
| ingra.punl.buscaCercano (pl, cerrado, pun, MARGEN2, soloVertices=false) |
Distancia del punto a la polilínea return { t:(V|A|S), i(base0), d2, p(i|p|p)}; |
| ingra.punl.distancia (pl, cerrado, pun, soloVertices=false) |
Distancia del punto a la polilínea |
| ingra.punl.igualUE (pl, p) |
¿Es igual al último? |
| ingra.punl.chequea (pl, cerrado, margen) |
Elimina duplicados, retorna nº eliminados |
| ingra.pun.pon |
Obsoleto, usar copia |
| ingra.pun.sum1 |
Obsoleto, usar suma1 |
| ingra.pun.res1 |
Obsoleto, usar resta1 |
| ingra.pun.sum |
Obsoleto, usar suma |
| ingra.pun.res |
Obsoleto, usar resta |
| ingra.pun.med |
Obsoleto, usar medio |
| ingra.pun.tam |
Obsoleto, usar tamano |
| ingra.punl.pon |
Obsoleto, usar copia |
| ingra.rec |
Librería de geometría: Rectángulos (rectángulo: {x1,y1,x2,y2}) |
| ingra.rec.copia (arg) |
Copia a rectangulo desde formatos: {x1,y1,x2,y2}, [x1,y1,x2,y2], [{x,y},{x,y}], {p,r,x,y,w,h}, {left,bottom,right,top}, "x1,y1,x2,y2" punl, rec, pun |
| ingra.rec.forma (arg) |
Copia si no tiene formato rectángulo |
|
Retorna el mismo |
| ingra.rec.agrega1 (r, pl) |
crece r para que entre pl |
| ingra.rec.mueve1 (r, pl) |
mueve r para incluir el punto/rectan/poligono |
| ingra.rec.mueveDentro1 (r, r2) |
mueve r, si es necesrio, para que se mantenga dentro de r2 |
| ingra.rec.creciente1 (r) |
creciente 1 |
|
Retorna rectángulo |
| ingra.rec.red (r, dec=0) |
redondea con ingra.red |
| ingra.rec.suma (r, r2) |
suma vertice a vértice r a arg |
| ingra.rec.resta (r, r2) |
resta vértice a vértice arg a r |
| ingra.rec.mul (r, fac) |
return { x1:r.x1*fac, y1:r.y1*fac, x2:r.x2*fac, y2:r.y2*fac }; }, |
| ingra.rec.margen (r, marx, mary) |
return { x1:r.x1-marx, y1:r.y1-mary, x2:r.x2+marx, y2:r.y2+mary }; }, |
| ingra.rec.agrega (r, pl) |
agrega a r una polilinea |
| ingra.rec.mueve (r, p) |
mueve r hasta contener p |
| ingra.rec.mueveDentro (r, r2) |
mueve r si es necesario, para que se mantenga dentro de r2 |
| ingra.rec.creciente (r) |
creciente 1 |
| ingra.rec.alineacion (r, ali) |
alineacion, de 4 > 0..8 |
| ingra.rec.xywh (arg) |
retorna rectangulo x1,y1,x2,y2 dado de la forma x1,y2,width,height |
|
retorna punl |
| ingra.rec.punl (r) |
convierte rec en lista de 2 puntos |
| ingra.rec.punl4 (r) |
convierte rec en lista de 4 puntos |
|
retorna punto |
| ingra.rec.recta (r1, r2, p, conCambioDeSigno) |
retorna punto o rectángulo; r1 es a r2 como p es a |
| ingra.rec.p1 (r) |
retorna p1 |
| ingra.rec.p2 (r) |
retorna p2 |
| ingra.rec.p3 (r) |
retorna p3 |
| ingra.rec.p4 (r) |
retorna p4 |
| ingra.rec.tamano (r, medio) |
retorna width, height |
| ingra.rec.medio (r) |
retorna el punto medio del rectangulo |
| ingra.rec.apunto (r, ali, enPixel) |
punto de alineación: -6-7-8 -3-4-5 0+1+2 +3+4+5 +6+7+8 +9+10+11 |
|
retorna valor |
| ingra.rec.mayor (r) |
Retorna la mayor dimensión(ancho o alto), en valor absoluto |
| ingra.rec.area (r) |
retorna area |
| ingra.rec.perimetro (r) |
retorna perímetro |
| ingra.rec.distancia2 (r) |
retorna distancia al cuadrado |
| ingra.rec.distancia (r) |
retorna distancia |
| ingra.rec.buscaCercano (r, pun, d2, soloVertices) |
retorna distancia del punto al rectangulo return { t:(V|A|S), i(base0), d2, p(i|p|p)}; |
| ingra.rec.compara (cod, a, b, decreciente) |
cod:per,are,x1,x2,y1,y2,xx,yy |
|
retorna bool |
| ingra.rec.vacio (r) |
|
| ingra.rec.igual (r0, r1) |
¿son r0 y r1 iguales? |
| ingra.rec.dentro (rec, pun, mar, g) |
en borde true p:pun|rec|punl COMPLETO dentro margenR? |
| ingra.rec.dentroParcial (rec, pun, mar, g) |
en borde true p:pun|rec|punl PARCIAL dentro, if g procesa rec.pix .pix4l .p4l |
| ingra.rec.intersecta (r, r2, incluyeBordes) |
interseca, en borde false |
| ingra.recl |
Librería de geometría: Rectángulos (rectángulo: pl[{x,y}]) con 2 o 3 puntos |
| ingra.recl.dentro (pl, pun, mar) |
¿Está dentro? > bool |
| ingra.recl.buscaCercano (pl, pun, D2) |
retorna distancia del punto al rectangulo > { t:VAS, i, p, d2, dentro}; |
| ingra.rin |
Rectángulos inclinados 2 puntos: centro y horizontal derecha |
| ingra.rin.punl4 (p0, p1, h2v, ali) |
o (pl,h2v); p0:centro p1:hotizontalDerecha hv:0o1cuadrado 1/1.618 h2v=!w?0:h/w |
| ingra.rin.dentroPunl4 (punl4, pun, margen) |
Comprueba si está pun dentro de pun14 |
| ingra.rin.limite (p0, p1, h2v) |
o (pl,h2v); p0:centro p1:superiorDerecha hv:0o1cuadrado // Math.atan2(yy,xx) h2v=yy/xx |
| ingra.rin.buscaCercano (pl, pun, D2) |
retorna distancia del punto al rectangulo > { t:VAS, i, p, d2, dentro}; |
| ingra.rin.de123 (punl) |
Formato ingrid7 a ingrid8; pl[1o2o3] a pl[1o2] |
| ingra.rin.a123 (punl) |
Formato ingrid8 a ingrid7; pl[1o2] a pl[1o2o3] |
| ingra.rin.punl4 (pl) |
Antiguo |
| ingra.rin.punl23 (pl) |
|
| ingra.rin.limite (pl) |
ingra.punl.limite(ingra.rin0.punl4(pl)) |
| ingra.rin.triangulo (p0, p1) |
Retorna lista de los puntos del triangulo equilatero con centro en p0 y radio hasta p1 |
| ingra.rin.cuadrado (p0, p1) |
Retorna lista de los puntos del cuadrado con centro en p0 y radio hasta p1 |
| ingra.rin.rectangulo (p0, p1, h2v) |
Retorna la lista de los puntos del rectangulo con centro en p0, radio menor p1 y proporcion entre lados de h2v |
| ingra.lin |
Librería de geometría: Líneas normalizadas (Línea: {a,b,c} ax+by+c=0) |
| ingra.lin.copia (arg) |
Copia línea desde formatos: {a,b,c} [x1,y1,x2,y2] o (x1,y1,x2,y2) [p1,p2] o (p1,p2) {x1,y1,x2,y2} |
| ingra.lin.forma (arg) |
Copia si no tiene formato línea |
|
Retorna línea |
| ingra.lin.normaliza (lin) |
En la forma normal a·x1+b·y1+c == distancia de x1,y1 a la recta |
| ingra.lin.perpendicular (lin, p) |
Perpendicular de un punto a una línea (perpendicular a lin que pasa por p) |
| ingra.lin.perpendicular3 (p1, p2, p) |
Perpendicular a la línea p1-p2 que pasa por p, si !p medio de p1,p2 |
|
Retorna punto |
| ingra.lin.intersecta (lin1, lin2) |
Intersección de dos líneas |
|
Retorna valor |
| ingra.lin.distancia (lin, p) |
Distancia o lugar geométrico unitario: (0)en (1)derecha (-1)izquierda. Distancia de un punto a una línea |
| ingra.rec.pon |
Obsoleto usar copia |
| ingra.rec.mas |
Obsoleto usar suma |
| ingra.rec.men |
Obsoleto usar resta |
| ingra.rec.por |
Obsoleto urar mul |
| ingra.lin.pon |
Obsoleto usar copia |
| ingra.cur |
Librería de geometría: Curvas (punl: {p1,...}) |
| ingra.cur.controlQuadratic4 (p1, p2, p3, p4, conContinuidad) |
Puntos de control entre puntos p1-p2 y p3-p > punto control {pi}; con continuidad tangentes comunes |
| ingra.cur.medioQuadratic4 (p1, p2, p3, p4, conContinuidad) |
Punto medio cuadrática entre p1-p2 y p3-p4 > pm |
| ingra.cur.medioQuadratic (p2, pc, p3) |
Punto medio cuadrática entre anclas p2,p3 y control pc |
| ingra.cur.medioQuadraticL (p2, pc, p3, nivel) |
Puntos medios cuadratica entre anclas p2,p3 y control pc > (nivel)puntos (0)1,(1)3,(2)7,(3)15,(4)31 |
| ingra.cur.controlBezier4 (p1, p2, p3, p4, conContinuidad) |
Puntos de control entre puntos p1-p2 y p3-p4 > puntos control {pi,pj}; con continuidad tangentes comunes |
| ingra.cur.medioBezier4 (p1, p2, p3, p4, conContinuidad) |
Punto medio bezier entre puntos p1-p2 y p3-p4 > pm |
| ingra.cur.medioBezier (p2, pi, pj, p3) |
Punto medio bezier, p2 y p3 puntos ancla; pi y pj puntos control > pm |
| ingra.cur.medioBezierL (p2, pi, pj, p3, nivel) |
Puntos medios bezier, p2 y p3 puntos ancla; pi y pj puntos control > (nivel)puntos (0)1,(1)3,(2)7,(3)15,(4)31 |
| ingra.cur.puntoBezier (p2, pi, pj, p3, t) |
Punto en curva bezier, p2 y p3 puntos ancla; pi y pj puntos control; t:0(p2)..1(p3) p5.js |
| ingra.cur.arco2p (p1, p2, enPixel) |
Cuarto de círculo definido por dos puntos, desde p1 a p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.arco3p (p1, p2, p3) |
Arco de círculo definido por tres puntos, desde p1 a p3 pasando por p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.elipsePunto (pc, a, b, ang) |
Retorna punto en elipse, pc punto central, a y b semiejes, ang en grados desde x+ |
| ingra.Impresor3 (imp) |
Objeto impresor {tema,pagina, title,style,script}) |
|
Funciones en línea, retornan html // Se incluyen en textos: "En un lugar "+imp.rojo("De la mancha")+" de cuyo nombre" |
| imp.enlinea (eti, html, style, properties) |
Etiqueta html en línea |
| imp.negrita (...al) |
span con estilo "font-weight:bold" > enlinea(span,...al) |
| imp.oblicua (...al) |
span con estilo "font-style:oblique" > enlinea(span,...al) |
| imp.tachada (...al) |
span con estilo "text-decoration:line-through" > enlinea(span,...al) |
| imp.rojo (...al) |
span con estilo "color:ROJO' > enlinea(span,...al) |
| imp.azul (...al) |
span con estilo "color:AZUL' > enlinea(span,...al) |
| imp.span (...al) |
> enlinea(span,...al) |
| imp.code (...al) |
> enlinea(code,...al) |
| imp._a (...al) |
> enlinea(a,...al), si no incluye href en properties: href=html |
|
Funciones de bloque, retornan identificador del bloque // ocupan un espacio horizontal completo, el identificador que se puede utilizar en los hijos del bloque |
| imp.etiqueta (eti, ...al) |
Etiqueta html: al:[pad,html,style,properties] |
| imp.h1 (...al) |
> etiqueta(h1,...al) |
| imp.h2 (...al) |
> etiqueta(h2,...al) |
| imp.h3 (...al) |
> etiqueta(h3,...al) |
| imp.h4 (...al) |
> etiqueta(h4,...al) |
| imp.h5 (...al) |
> etiqueta(h5,...al) |
| imp.h6 (...al) |
> etiqueta(h6,...al) |
| imp.p (...al) |
> etiqueta(p,...al) |
| imp.a (...al) |
> etiqueta(a,...al) |
| imp.table (...al) |
> etiqueta(table,...al), |
| imp.tr (...al) |
> etiqueta(tr,...al) |
| imp.td (...al) |
> etiqueta(h1,...al), si padre es 'table', inserta 'tr' |
| imp.th (...al) |
> etiqueta(h1,...al), si padre es 'table', inserta 'tr' |
| imp.div (...al) |
> etiqueta(div,...al) |
| imp.hr (...al) |
> etiqueta(hr,...al) |
| imp.canvas (...al) |
> etiqueta(canvas,...al) |
| imp.img (...al) |
> etiqueta(img,...al), si no incluye src en properties: src=html |
|
Utilidades |
| imp.error (data) |
> div ERROR:... rojo |
| imp.titular (...al) |
Monta una envolvente con h3, div {pageBreakInside:'avoid'} envolviendo (etiqueta h3 ...al) > retorna identificador de div |
| imp.salto (pad=0) |
Salta página, incrementa contador imp.pagn, agrega div con {pageBreakAfter:'always'}), agrega ... en presentación |
|
Funciones compuestas |
| imp.preparaTabla (tabla) |
Prepara tabla antes de imprimir, chequea o crea caml, analiza tipo de datos si no definido |
| imp.tabla (tabla, style, properties) |
Tabla con documentos o datos y modificadores, ver imp.preparaTabla |
| imp.imagenes () |
Lista de imágenes, ima:{url,url2,pis,cod}, tit:titulo num:número por fila |
| imp.inca (meta, style, properties) |
Mapa con objeto INCA |
| imp.igra (igra, style, properties) |
Gráfica con objeto IGRA, {pad,...} |
| imp.qrcode (qrcode, style, properties) |
Gráfica con imagen QR |
|
Impresiones múltiples |
| imp.iniciaParcial () |
Inicia impresiones parciales parcial, ingra.Impresor3.parcial:{oll,imp} |
| imp.montaParcial (cb) |
Monta impresiones parciales |
| ingra.dialogo (op, cbo) |
Clase base diálogos {titulo,pista, tipo(error|aviso|informa), titular,mensaje,contenido(cuerpo) botones:[{res,pis,ret,click}], miliseguntos } > (0,1(botones),-13(enter),-27(escape),-1(cierra),-2(tiempo),-3(contextual) botones=["Cierra"] |
| ingra.dialogoCierra (i) |
Cierra el último diálogo abierto |
| ingra.dialogoMensaje (html) |
Actualiza el último diálogo abierto |
| ingra.dialogoError (titulo, mensaje, op, cbo) |
Presenta diálogo de error; op|milisegundos !!!!! > cbo({error}) |
| ingra.dialogoAviso (titulo, mensaje, op, cbo) |
Presenta diálogo de aviso; op|milisegundos |
| ingra.dialogoInforma (titular, mensaje, op, cbo) |
Presenta diálogo de unformación; op|milisegundos |
| ingra.dialogoPregunta (titular, mensaje, botones, cbo) |
Diálogo pregunta; (titular|op, [mensaje], [botones=["Si","No"]], cbo) > ret:(0(b0|-13) N(bn) Ultimo(Ultimo|-27|-1|-2|-3) |
| ingra.dialogoPreguntaSN (titular, mensaje, fSi, fNo, fResto) |
Diálogo pregunta "Si" o "No"; ([titular], mensaje, fSi, [fNo], [fResto]) > fSi(0), fNo(1), fResto(-13,-1,-2,-3,-27); si no fResto (-13)Si (resto)No |
| ingra.dialogoPreguntaAC (titular, mensaje, fAcepta, fCancela, fResto) |
Diálogo pregunta T('Acepta') o T(T('Cancela')); ([titular], mensaje, fAcepta, [fCancela], [fResto]) > fAcepta(0), fCancela(1), fResto(-13,-1,-2,-3,-27); si no fResto (-13)Acepta (resto)Cancela |
| ingra.dialogoEdita (titular, mensaje, valor, botones, cbo) |
Diálogo con editor; (titular|op, [mensaje], [valor], [botones], [cbo]) > ingra.dialogoEdita1 |
| ingra.dialogoEditaAC (titular, mensaje, valor, fAcepta, fCancela) |
Diálogo con editor; (titular, [mensaje], [valor], fAcepta, [fCancela]) |
| ingra.dialogoSeleccion (titulo, columnas, filas, actual, cb) |
Dialogo de selección |
| ingra.dialogoSeleccionTCD (titulo, filas, actual, cb) |
Diálogo de selección Tipo|Código|Descripción |
| ingra.dialogoMultiseleccion (op, cb) |
Multiselección {titulo, columnas:[{}]|"res;tip;ali|...", filas:[[]], sell, ...} > (ret,sell) titulo="Diálogo de selección múltiple" botones=[T('Acepta'),T('Cancela')] |
| ingra.dialogoColor (op, fAcepta, fCancela) |
Diálogo de selección de color; {color,...} > {color:x8, ret} ret:(0,-13)acepta (1,2,-27)cancela titulo="Selección de color" botones=[T('Acepta'),T('Cancela')] |
| ingra.dialogoIcono (op, fAcepta, fCancela) |
Diálogo de selección de icono; {icono,...} > (icono,ret) titulo="Selección de iconos" botones=["Deselecciona",T('Acepta'),T('Cancela')] |
| ingra.dialogoProgreso (titular, op) |
Diálogo de progreso; op|titular botones:['Interrmupir'] |
| ingra.dialogoProgresoNI (op) |
Diálogo de progreso No Interrumpible; op|titular botones:['No interrumpible'] solamente cierra con ingra.dialogo.cierra |
| ingra.inter (html, creasino) |
Actualización de diálogo actual y comprobación de interrupción |