diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/appearance.json b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/appearance.json index a169246..00d0272 100644 --- a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/appearance.json +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/appearance.json @@ -1,4 +1,5 @@ { "theme": "obsidian", - "accentColor": "#f5ad5c" + "accentColor": "#f5ad5c", + "baseFontSize": 16 } \ No newline at end of file diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/community-plugins.json b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/community-plugins.json index 6bcf1e3..f73177d 100644 --- a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/community-plugins.json +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/community-plugins.json @@ -1,3 +1,4 @@ [ - "pdf-plus" + "pdf-plus", + "number-headings-obsidian" ] \ No newline at end of file diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/data.json b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/data.json new file mode 100644 index 0000000..c431051 --- /dev/null +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/data.json @@ -0,0 +1,13 @@ +{ + "skipTopLevel": true, + "firstLevel": 1, + "maxLevel": 6, + "styleLevel1": "1", + "styleLevelOther": "1", + "auto": true, + "separator": ".", + "contents": "", + "skipHeadings": "", + "startAt": "1", + "off": false +} \ No newline at end of file diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/main.js b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/main.js new file mode 100644 index 0000000..baa0c03 --- /dev/null +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/main.js @@ -0,0 +1,1138 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +function getActiveView(app) { + const activeView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + return activeView !== null && activeView !== void 0 ? activeView : undefined; +} +function isViewActive(app) { + const activeView = getActiveView(app); + if (activeView && activeView.file) + return true; + return false; +} +function getViewMetadata(app) { + const activeView = getActiveView(app); + if (activeView && activeView.file) { + const data = app.metadataCache.getFileCache(activeView.file) || {}; + return data; + } + return undefined; +} +function getViewInfo(app) { + const activeView = getActiveView(app); + const data = getViewMetadata(app); + const editor = activeView ? activeView.editor : undefined; + if (activeView && data && editor) { + return { + activeView, data, editor + }; + } + return undefined; +} + +const roman_map = { + M: 1000, + CM: 900, + D: 500, + CD: 400, + C: 100, + XC: 90, + L: 50, + XL: 40, + X: 10, + IX: 9, + V: 5, + IV: 4, + I: 1 +}; + +const allChars = Object.keys(roman_map); +const allNumerals = Object.values(roman_map); +const romanPattern = + /^(M{1,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|M{0,4}(CM|C?D|D?C{1,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|M{0,4}(CM|CD|D?C{0,3})(XC|X?L|L?X{1,3})(IX|IV|V?I{0,3})|M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|I?V|V?I{1,3}))$/; + +const romanize = (decimal) => { + if ( + decimal <= 0 || + typeof decimal !== 'number' || + Math.floor(decimal) !== decimal + ) { + throw new Error('requires an unsigned integer') + } + if (decimal >= 4000) { + throw new Error('requires max value of less than 3999 or less') + } + let roman = ''; + for (let i = 0; i < allChars.length; i++) { + while (decimal >= allNumerals[i]) { + decimal -= allNumerals[i]; + roman += allChars[i]; + } + } + return roman +}; + +const deromanize = (romanStr) => { + if (typeof romanStr !== 'string') { + throw new Error('requires a string') + } + if (!romanPattern.test(romanStr)) { + throw new Error('requires valid roman numeral string') + } + let romanString = romanStr.toUpperCase(); + let arabic = 0; + let iteration = romanString.length; + while (iteration--) { + let cumulative = roman_map[romanString[iteration]]; + if (cumulative < roman_map[romanString[iteration + 1]]) { + arabic -= cumulative; + } else { + arabic += cumulative; + } + } + return arabic +}; + +var romans = { + deromanize, + romanize, + allChars, + allNumerals +}; + +// Validates the string using a regex to ensure is is a valid arabic numbering value +function isValidArabicNumberingValueString(s) { + const regex = /^[0-9]+$/; + return regex.test(s); +} +// Validates the string using a regex to ensure is is a valid alphabet numbering value +function isValidAlphabetNumberingValueString(s) { + const regex = /^[A-Z]$/; + return regex.test(s); +} +// Validates the string using a regex to ensure is is a valid roman numbering value +function isValidRomanNumberingValueString(s) { + const regex = /^[0IVXLCDM]+$/; // This includes zero for zeroth testing + return regex.test(s); +} +function printableNumberingToken(t) { + switch (t.style) { + case '1': + return t.value.toString(); + case 'A': + return t.value; + case 'I': + return t.value; + } +} +function zerothNumberingTokenInStyle(style) { + switch (style) { + case '1': + return { style: '1', value: 0 }; + case 'A': + return { style: 'A', value: 'Z' }; + case 'I': + return { style: 'I', value: '0' }; + } +} +function firstNumberingTokenInStyle(style) { + switch (style) { + case '1': + return { style: '1', value: 1 }; + case 'A': + return { style: 'A', value: 'A' }; + case 'I': + return { style: 'I', value: 'I' }; + } +} +function nextNumberingToken(t) { + switch (t.style) { + case '1': + return { style: '1', value: t.value + 1 }; + case 'A': + if (t.value === 'Z') + return { style: 'A', value: 'A' }; + else + return { style: 'A', value: String.fromCharCode(t.value.charCodeAt(0) + 1) }; + case 'I': + if (t.value === '0') + return { style: 'I', value: 'I' }; + else + return { style: 'I', value: romans.romanize(romans.deromanize(t.value) + 1) }; + } +} +function previousNumberingToken(t) { + switch (t.style) { + case '1': + return { style: '1', value: t.value - 1 }; + case 'A': + if (t.value === 'A') + return { style: 'A', value: 'Z' }; + else + return { style: 'A', value: String.fromCharCode(t.value.charCodeAt(0) - 1) }; + case 'I': + if (t.value === 'I') + return { style: 'I', value: '0' }; + else + return { style: 'I', value: romans.romanize(romans.deromanize(t.value) - 1) }; + } +} +function makeNumberingString(numberingStack) { + let numberingString = ''; + for (let i = 0; i < numberingStack.length; i++) { + if (i === 0) { + numberingString += ' '; + } + else { + numberingString += '.'; + } + numberingString += printableNumberingToken(numberingStack[i]); + } + return numberingString; +} +function startAtOrZerothInStyle(startAtSettingString, style) { + if (startAtSettingString === '') + return zerothNumberingTokenInStyle(style); + let firstNumberingTokenFromSetting; + switch (style) { + case '1': + if (!isValidArabicNumberingValueString(startAtSettingString)) + return zerothNumberingTokenInStyle(style); + firstNumberingTokenFromSetting = { style: '1', value: parseInt(startAtSettingString) }; + break; + case 'A': + if (!isValidAlphabetNumberingValueString(startAtSettingString)) + return zerothNumberingTokenInStyle(style); + firstNumberingTokenFromSetting = { style: 'A', value: startAtSettingString }; + break; + case 'I': + if (!isValidRomanNumberingValueString(startAtSettingString)) + return zerothNumberingTokenInStyle(style); + firstNumberingTokenFromSetting = { style: 'I', value: startAtSettingString }; + break; + } + // Convert the first numbering token to a zeroth numbering token + return previousNumberingToken(firstNumberingTokenFromSetting); +} + +const DEFAULT_SETTINGS = { + skipTopLevel: false, + firstLevel: 1, + maxLevel: 6, + styleLevel1: '1', + styleLevelOther: '1', + auto: false, + separator: '', + contents: '', + skipHeadings: '', + startAt: '', + off: false +}; +function isValidNumberingStyleString(s) { + if (s === 'A' || s === '1' || s === 'I') + return true; + return false; +} +function isValidNumberingValueString(s) { + if (s === '' || isValidArabicNumberingValueString(s) || isValidAlphabetNumberingValueString(s) || isValidRomanNumberingValueString(s)) + return true; + return false; +} +function isValidFlag(f) { + if (f === true || f === false) + return true; + return false; +} +function isValidFirstOrMaxLevel(x) { + if (typeof x === 'number' && x >= 1 && x <= 6) + return true; + return false; +} +function isValidSeparator(x) { + return typeof x === 'string' && + (x === '' || + x === ':' || x === ' :' || + x === '.' || x === ' .' || + x === '-' || x === ' -' || + x === '—' || x === ' —' || /* em-dash */ + x === ')' || x === ' )'); +} +function isValidBlockIdSetting(x) { + if (typeof x === 'string' && (x === '' || x.startsWith('^'))) + return true; + return false; +} +function isNonEmptyBlockId(x) { + if (x.length > 2 && x.startsWith('^')) + return true; + return false; +} + +function createSupportFlagsFromSettings(styleLevel1, styleLevelOther) { + return { + alphabet: styleLevel1 === 'A' || styleLevelOther === 'A', + roman: styleLevel1 === 'I' || styleLevelOther === 'I' + }; +} +// Get the regex for the header string, based on the support flags. The generated regex is used to find the range of the header prefix. +// The regex is generated dynamically, because the regex is different depending on the support flags. +function getRegexForHeaderString(flags) { + if (flags.alphabet && flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.|[A-Z]\.|[IVXLCDM]+\.)*([0-9]+|[A-Z]|[IVXLCDM]+)?( )?[)—:.-]?( )+/g; + } + else if (!flags.alphabet && flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.|[IVXLCDM]+\.)*([0-9]+|[IVXLCDM]+)?( )?[)—:.-]?( )+/g; + } + else if (flags.alphabet && !flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.|[A-Z]\.)*([0-9]+|[A-Z])?( )?[)—:.-]?( )+/g; + } + else if (!flags.alphabet && !flags.roman) { + // Regex to match the heading prefix, including the space after the hash(es), but not the heading text + return /^\s{0,4}#+( )?([0-9]+\.)*([0-9]+)?( )?[)—:.-]?( )+/g; + } + throw new Error('Unexpected combination of support flags'); +} +// Find the range of the heading prefix, including the space after any numbering, but not the heading text +function findRangeInHeaderString(lineText, lineNumber, flags) { + const regex = getRegexForHeaderString(flags); + if (!lineText) + return undefined; + const matches = lineText.match(regex); + if (matches && matches.length !== 1) { + // eslint-disable-next-line no-console + console.log("Unexpected heading format: '" + lineText + "'"); + return undefined; + } + const match = matches ? matches[0] : ''; + const from = { + line: lineNumber, + ch: 0 + }; + const to = { + line: lineNumber, + ch: match.length + }; + return { from, to }; +} +function updateSettingsFromFrontMatterFormatPart(part, settings) { + // Parse the separator + let partWithoutSeparator = part; + const potentialTwoCharSeparator = part.slice(-2); + if (isValidSeparator(potentialTwoCharSeparator)) { + settings.separator = potentialTwoCharSeparator; + partWithoutSeparator = part.slice(0, -2); + } + else { + const potentialOneCharSeparator = part.slice(-1); + if (isValidSeparator(potentialOneCharSeparator)) { + settings.separator = potentialOneCharSeparator; + partWithoutSeparator = part.slice(0, -1); + } + else { + settings.separator = ''; + } + } + // Parse the numbering style + const descriptors = partWithoutSeparator.split('.'); + let firstNumberedDescriptor = 0; + // Handle the case where the first descriptor is an underscore + if (descriptors.length > 1 && descriptors[0] === '_') { + // The first descriptor is an instruction to skip top levels, so skip them + settings.skipTopLevel = true; + firstNumberedDescriptor = 1; + } + else { + settings.skipTopLevel = false; + } + if (descriptors.length - firstNumberedDescriptor >= 2) { + const styleLevel1 = descriptors[firstNumberedDescriptor]; + if (isValidNumberingStyleString(styleLevel1)) { + settings.styleLevel1 = styleLevel1; + } + const styleLevelOther = descriptors[firstNumberedDescriptor + 1]; + if (isValidNumberingStyleString(styleLevelOther)) { + settings.styleLevelOther = styleLevelOther; + } + } + return settings; +} + +const AUTO_PART_KEY = 'auto'; +const FIRST_LEVEL_PART_KEY = 'first-level'; +const MAX_LEVEL_PART_KEY = 'max'; +const CONTENTS_PART_KEY = 'contents'; +const SKIP_PART_KEY = 'skip'; +const START_AT_PART_KEY = 'start-at'; +const OFF_PART_KEY = 'off'; +function parseCompactFrontMatterSettings(fm) { + const entry = obsidian.parseFrontMatterEntry(fm, 'number headings'); + if (entry) { + const entryString = String(entry); + const parts = entryString.split(','); + let settings = Object.assign({}, DEFAULT_SETTINGS); + for (const part of parts) { + const trimmedPart = part.trim(); + if (trimmedPart.length === 0) + continue; + if (trimmedPart === OFF_PART_KEY) { + // Parse off part + settings.off = true; + } + else if (trimmedPart === AUTO_PART_KEY) { + // Parse auto numbering part + settings.auto = true; + } + else if (trimmedPart.startsWith(FIRST_LEVEL_PART_KEY)) { + // Parse first level part + const nstring = trimmedPart.substring(FIRST_LEVEL_PART_KEY.length + 1); + const n = parseInt(nstring); + if (isValidFirstOrMaxLevel(n)) { + settings.firstLevel = n; + } + } + else if (trimmedPart.startsWith(MAX_LEVEL_PART_KEY)) { + // Parse max level part + const nstring = trimmedPart.substring(MAX_LEVEL_PART_KEY.length + 1); + const n = parseInt(nstring); + if (isValidFirstOrMaxLevel(n)) { + settings.maxLevel = n; + } + } + else if (trimmedPart.startsWith(START_AT_PART_KEY)) { + // Parse "start at" part + const value = trimmedPart.substring(START_AT_PART_KEY.length + 1); + if (isValidNumberingValueString(value)) { + settings.startAt = value; + } + } + else if (trimmedPart.startsWith(CONTENTS_PART_KEY)) { + if (trimmedPart.length <= CONTENTS_PART_KEY.length + 1) + continue; + // Parse contents heading part + const tocHeadingBlockIdName = trimmedPart.substring(CONTENTS_PART_KEY.length + 1); + if (isValidBlockIdSetting(tocHeadingBlockIdName)) { + settings.contents = tocHeadingBlockIdName; + } + } + else if (trimmedPart.startsWith(SKIP_PART_KEY)) { + if (trimmedPart.length <= SKIP_PART_KEY.length + 1) + continue; + // Parse skip heading part + const skipHeadingBlockIdName = trimmedPart.substring(SKIP_PART_KEY.length + 1); + if (isValidBlockIdSetting(skipHeadingBlockIdName)) { + settings.skipHeadings = skipHeadingBlockIdName; + } + } + else { + // Parse formatting part + settings = updateSettingsFromFrontMatterFormatPart(trimmedPart, settings); + } + } + return settings; + } + return undefined; +} +const getFrontMatterSettingsOrAlternative = ({ frontmatter }, alternativeSettings) => { + var _a, _b, _c, _d, _e; + if (frontmatter !== undefined) { + const decompactedSettings = parseCompactFrontMatterSettings(frontmatter); + if (decompactedSettings !== undefined) + return decompactedSettings; + // NOTE: Everything below is for backwards compatibility only + const skipTopLevelEntry = (_a = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-skip-top-level')) !== null && _a !== void 0 ? _a : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-skip-top-level'); + const skipTopLevel = isValidFlag(skipTopLevelEntry) ? skipTopLevelEntry : alternativeSettings.skipTopLevel; + const maxLevelEntry = (_b = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-max-level')) !== null && _b !== void 0 ? _b : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-max-level'); + const maxLevel = isValidFirstOrMaxLevel(maxLevelEntry) ? maxLevelEntry : alternativeSettings.maxLevel; + const styleLevel1Entry = String((_c = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-style-level-1')) !== null && _c !== void 0 ? _c : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-1')); + const styleLevel1 = isValidNumberingStyleString(styleLevel1Entry) ? styleLevel1Entry : alternativeSettings.styleLevel1; + const styleLevelOtherEntry = String((_d = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-style-level-other')) !== null && _d !== void 0 ? _d : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-style-level-other')); + const styleLevelOther = isValidNumberingStyleString(styleLevelOtherEntry) ? styleLevelOtherEntry : alternativeSettings.styleLevelOther; + const autoEntry = (_e = obsidian.parseFrontMatterEntry(frontmatter, 'number-headings-auto')) !== null && _e !== void 0 ? _e : obsidian.parseFrontMatterEntry(frontmatter, 'header-numbering-auto'); + const auto = isValidFlag(autoEntry) ? autoEntry : alternativeSettings.auto; + return Object.assign(Object.assign({}, alternativeSettings), { skipTopLevel, maxLevel, styleLevel1, styleLevelOther, auto }); + } + else { + return alternativeSettings; + } +}; +function settingsToCompactFrontMatterValue(settings) { + if (settings.off) + return OFF_PART_KEY; + const autoPart = settings.auto ? 'auto, ' : ''; + const firstLevelPart = `first-level ${settings.firstLevel}, `; + const maxPart = `max ${settings.maxLevel}, `; + const contentsPart = settings.contents && settings.contents.length > 0 ? `contents ${settings.contents}, ` : ''; + const skipHeadingsPart = settings.skipHeadings && settings.skipHeadings.length > 0 ? `skip ${settings.skipHeadings}, ` : ''; + const skipTopLevelString = settings.skipTopLevel ? '_.' : ''; + const stylePart = `${skipTopLevelString}${settings.styleLevel1}.${settings.styleLevelOther}${settings.separator}`; + const startAtPart = settings.startAt !== '' ? `start-at ${settings.startAt}, ` : ''; + return autoPart + firstLevelPart + maxPart + contentsPart + skipHeadingsPart + startAtPart + stylePart; +} +const saveSettingsToFrontMatter = (fileManager, file, settings) => { + fileManager.processFrontMatter(file, frontmatter => { + const v = settingsToCompactFrontMatterValue(settings); + frontmatter['number headings'] = v; + }); +}; + +class NumberingDoneModal extends obsidian.Modal { + constructor(app, config) { + super(app); + this.config = config; + } + onOpen() { + const { contentEl, titleEl } = this; + titleEl.setText('Number Headings - Successfully Completed'); + contentEl.createEl('div', { text: this.config.message }); + contentEl.createEl('pre', { text: this.config.preformattedMessage }); + contentEl.createEl('div', { text: "Do you want to save these settings in the document's front matter?", cls: 'number-headings-question' }); + const containerForButtons = contentEl.createEl('div', { cls: 'number-headings-button-container' }); + const noButton = containerForButtons.createEl('button', {}); + noButton.setText('No'); + noButton.onClickEvent((ev) => { + this.close(); + return ev; + }); + const yesButton = containerForButtons.createEl('button', {}); + yesButton.setText('Yes, save settings in document'); + yesButton.onClickEvent((ev) => { + this.config.saveSettingsCallback(false); + this.close(); + return ev; + }); + const yesAndAutoButton = containerForButtons.createEl('button', {}); + yesAndAutoButton.setText('Yes, save settings in document, and automatically number'); + yesAndAutoButton.onClickEvent((ev) => { + this.config.saveSettingsCallback(true); + this.close(); + return ev; + }); + } + onClose() { + const { contentEl, titleEl } = this; + contentEl.empty(); + titleEl.empty(); + } +} +function showNumberingDoneMessage(app, settings) { + const saveSettingsCallback = (shouldAddAutoFlag) => { + const tweakedSettings = Object.assign({}, settings); + if (shouldAddAutoFlag) + tweakedSettings.auto = true; + const file = app.workspace.getActiveFile(); + if (file) { + saveSettingsToFrontMatter(app.fileManager, file, tweakedSettings); + } + }; + const config = { + message: `Successfully updated all heading numbers in the document, using the settings below. + See settings panel to change how headings are numbered, or use front matter + (see settings panel).`, + preformattedMessage: `Skip top heading level: ${settings.skipTopLevel} +First heading level: ${settings.firstLevel} +Start numbering first heading at: ${settings.startAt} +Maximum heading level: ${settings.maxLevel} +Style for level 1 headings: ${settings.styleLevel1} +Style for lower level headings (below level 1): ${settings.styleLevelOther} +Separator: ${settings.separator} +Table of Contents Anchor: ${settings.contents} +Skip Headings Anchor: ${settings.skipHeadings}`, + saveSettingsCallback + }; + const leaf = app.workspace.activeLeaf; + if (leaf) { + new NumberingDoneModal(app, config).open(); + } +} + +const TOC_LIST_ITEM_BULLET = '-'; +function makeHeadingHashString(editor, heading) { + const regex = /^\s{0,4}#+/g; + const headingLineString = editor.getLine(heading.position.start.line); + if (!headingLineString) + return undefined; + const matches = headingLineString.match(regex); + if (!matches) + return undefined; + if (matches.length !== 1) { + // eslint-disable-next-line no-console + console.log("Unexpected heading format: '" + headingLineString + "'"); + return undefined; + } + const match = matches[0]; + return match.trimLeft(); +} +function findHeadingPrefixRange(editor, heading, flags) { + const lineNumber = heading.position.start.line; + const lineText = editor.getLine(lineNumber); + return findRangeInHeaderString(lineText, lineNumber, flags); +} +function cleanHeadingTextForToc(htext) { + if (htext.contains('^')) { + const x = htext.split('^'); + if (x.length > 1) { + return x[0].trim(); + } + } + return htext.trim(); +} +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function createTocEntry(h, settings, initialHeadingLevel) { + const text = h.heading; + const cleanText = cleanHeadingTextForToc(text); + let bulletIndent = ''; + const startLevel = initialHeadingLevel; + for (let i = startLevel; i < h.level; i++) { + bulletIndent += '\t'; + } + const entryLink = `[[#${text}|${cleanText}]]`; + return bulletIndent + TOC_LIST_ITEM_BULLET + ' ' + entryLink; +} +// Replace a range, but only if there is a change in text, to prevent poluting the undo stack +function replaceRangeEconomically(editor, changes, range, text) { + const previousText = editor.getRange(range.from, range.to); + if (previousText !== text) { + changes.push({ + text: text, + from: range.from, + to: range.to + }); + } +} +const updateHeadingNumbering = (viewInfo, settings) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + const supportFlags = createSupportFlagsFromSettings(settings.styleLevel1, settings.styleLevelOther); + let previousLevel = 1; + let numberingStack = [startAtOrZerothInStyle(settings.startAt, settings.styleLevel1)]; + if (settings.firstLevel > 1) { + previousLevel = settings.firstLevel; + } + else if (settings.skipTopLevel) { + previousLevel = 2; + } + const changes = []; + for (const heading of headings) { + // Update the numbering stack based on the level and previous level + const level = heading.level; + // Handle skipped & ignored levels. + if ((settings.firstLevel > level) || (settings.skipTopLevel && level === 1)) { + // Resets the numbering when a level is skipped. + // Note: This leaves headings as they are, allowing people to have numbers at the start of + // ignored headings. + numberingStack = [startAtOrZerothInStyle(settings.startAt, settings.styleLevel1)]; + if (settings.firstLevel > 1) { + previousLevel = settings.firstLevel; + } + else if (settings.skipTopLevel) { + previousLevel = 2; + } + continue; + } + // Handle skipped headings + if (settings.skipHeadings.length > 0) { + if (heading.heading.endsWith(settings.skipHeadings)) { + continue; + } + } + // Adjust numbering stack + if (level === previousLevel) { + const x = numberingStack.pop(); + if (x !== undefined) { + numberingStack.push(nextNumberingToken(x)); + } + } + else if (level < previousLevel) { + for (let i = previousLevel; i > level; i--) { + numberingStack.pop(); + } + const x = numberingStack.pop(); + if (x !== undefined) { + numberingStack.push(nextNumberingToken(x)); + } + } + else if (level > previousLevel) { + for (let i = previousLevel; i < level; i++) { + numberingStack.push(firstNumberingTokenInStyle(settings.styleLevelOther)); + } + } + // Set the previous level to this level for the next iteration + previousLevel = level; + if (level > settings.maxLevel) { + // If we are above the max level, just don't number it + continue; + } + // Find the range to replace, and then do it + const prefixRange = findHeadingPrefixRange(editor, heading, supportFlags); + if (prefixRange === undefined) + return; + const headingHashString = makeHeadingHashString(editor, heading); + if (headingHashString === undefined) + return; + const prefixString = makeNumberingString(numberingStack); + replaceRangeEconomically(editor, changes, prefixRange, headingHashString + prefixString + settings.separator + ' '); + } + // Execute the transaction to make all the changes at once + if (changes.length > 0) { + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Applying headings numbering changes:', changes.length); + editor.transaction({ + changes: changes + }); + } +}; +const updateTableOfContents = (viewInfo, settings) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + if (!isNonEmptyBlockId(settings.contents)) + return; + let tocHeading; + let tocBuilder = '\n'; + const changes = []; + // In case headings start above level 1, we don't want to indent the bullets too much + let initialHeadingLevel = 1; + if (headings.length > 0) { + initialHeadingLevel = headings[0].level; + } + for (const heading of headings) { + // ORDERING: Important to find the TOC heading before skipping skipped headings, since that is for numbering + // Find the TOC heading + if (heading.heading.endsWith(settings.contents)) { + tocHeading = heading; + } + /* This code lets us skip TOC lines for skipped headings, but doesn't work well with first-level setting + if ((settings.skipTopLevel && heading.level === 1) || (heading.level > settings.maxLevel)) { + continue + } + */ + const tocEntry = createTocEntry(heading, settings, initialHeadingLevel); + tocBuilder += tocEntry + '\n'; + } + // Insert the generated table of contents + if (tocHeading) { + const from = { + line: tocHeading.position.start.line + 1, + ch: 0 + }; + // Find the end of the TOC section + const startingLine = tocHeading.position.start.line + 1; + let endingLine = startingLine; + let foundList = false; + const lastLineInEditor = editor.lastLine(); + for (;; endingLine++) { + const line = editor.getLine(endingLine); + if (line === undefined || endingLine > lastLineInEditor) { + // Reached end of file, insert at the start of the TOC section + endingLine = startingLine; + break; + } + const trimmedLineText = line.trimStart(); + if (foundList) { + if (!trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) + break; + if (trimmedLineText.startsWith('#')) + break; + } + else { + if (trimmedLineText.startsWith(TOC_LIST_ITEM_BULLET)) { + foundList = true; + } + else if (trimmedLineText.startsWith('#')) { + // Reached the next heading without finding existing TOC list, insert at the start of the TOC section + endingLine = startingLine; + break; + } + else { + continue; + } + } + } + if (tocBuilder === '\n') { + tocBuilder = ''; + } + const to = { + line: endingLine, + ch: 0 + }; + const range = { from, to }; + replaceRangeEconomically(editor, changes, range, tocBuilder); + } + // Execute the transaction to make all the changes at once + if (changes.length > 0) { + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Applying table of contents changes:', changes.length); + editor.transaction({ + changes: changes + }); + } +}; +const removeHeadingNumbering = (viewInfo) => { + var _a; + if (!viewInfo) + return; + const headings = (_a = viewInfo.data.headings) !== null && _a !== void 0 ? _a : []; + const editor = viewInfo.editor; + const changes = []; + for (const heading of headings) { + const prefixRange = findHeadingPrefixRange(editor, heading, { alphabet: true, roman: true }); + if (prefixRange === undefined) + return; + const headingHashString = makeHeadingHashString(editor, heading); + if (headingHashString === undefined) + return; + replaceRangeEconomically(editor, changes, prefixRange, headingHashString + ' '); + } + if (changes.length > 0) { + editor.transaction({ + changes: changes + }); + } +}; + +class NumberHeadingsPluginSettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Number Headings - Settings' }); + containerEl.createEl('div', { text: 'To add numbering to your document, bring up the command window (on Mac, type CMD+P), and then type "Number Headings" to see a list of available commands.' }); + containerEl.createEl('br', {}); + containerEl.createEl('div', { text: 'If the document has front matter defined with the below settings, the project-wide settings defined on this screen will be ignored. You can define front matter like this:' }); + containerEl.createEl('pre', { + text: ` --- + alias: + - Example Alias + tags: + - example-tag + number headings: first-level 1, start-at 2, max 6, 1.1, auto, contents ^toc + ---` + }); + containerEl.createEl('div', { + text: ` + The 'number headings' front matter key is used to store numbering settings specific to the file. There are four possible options + in the value to the right of the colon, separated by commas. + ` + }); + const ul = containerEl.createEl('ul', {}); + const li0 = ul.createEl('li', {}); + li0.createEl('b', { text: 'Automatic numbering' }); + li0.createEl('span', { text: ': If \'auto\' appears, the document will be automatically numbered.' }); + const li1 = ul.createEl('li', {}); + li1.createEl('b', { text: 'First level to number' }); + li1.createEl('span', { text: ': If \'first-level 2\' appears, the numbering will start at the second level' }); + const li2 = ul.createEl('li', {}); + li2.createEl('b', { text: 'Start numbering first heading at' }); + li2.createEl('span', { text: ': If \'start-at C\' appears, the numbering of the first level will start at C, instead of A' }); + const li3 = ul.createEl('li', {}); + li3.createEl('b', { text: 'Maximum level to number' }); + li3.createEl('span', { text: ': If \'max 6\' appears, the headings above level 6 will be skipped.' }); + const li4 = ul.createEl('li', {}); + li4.createEl('b', { text: 'Table of contents anchor' }); + li4.createEl('span', { text: ': If \'contents ^toc\' appears, the heading that ends with the anchor ^toc will have a table of contents inserted beneath it.' }); + const li41 = ul.createEl('li', {}); + li41.createEl('b', { text: 'Skip headings anchor' }); + li41.createEl('span', { text: ': If \'skip ^skipped\' appears, the heading that ends with the anchor ^skipped will not be numbered.' }); + const li5 = ul.createEl('li', {}); + li5.createEl('b', { text: 'Numbering style' }); + li5.createEl('span', { + text: `: + A style text like '1.1', 'A.1', or '_.1.1' tells the plugin how to format the headings. + If a style string ends with '.' (a dot), ':' (a colon), '-' (a dash), '—' (an emdash), or ')' (a right parenthesis), the heading numbers will be separated from the heading title + with that symbol.` + }); + const ul3 = li5.createEl('ul', {}); + ul3.createEl('li', { + text: ` + For example, '1.1' means both top level and other headings will be numbered starting from '1'. + ` + }); + ul3.createEl('li', { + text: ` + For example, 'A.1' means top level headings will be numbered starting from 'A'. + ` + }); + ul3.createEl('li', { + text: ` + For example, '_.A.1' means top level headings will NOT be numbered, but the next levels will be numbered with letters and numbers. + ` + }); + ul3.createEl('li', { + text: ` + For example, '1.1:' means headings will look like '## 2.4: Example Heading' + ` + }); + ul3.createEl('li', { + text: ` + For example, 'A.1-' means headings will look like '## B.5- Example Heading' + ` + }); + ul3.createEl('li', { + text: ` + For example, 'I.A —' means headings will look like '## IV.A — Example Heading' (with Roman numerals) + ` + }); + const li100 = ul.createEl('li', {}); + li100.createEl('b', { text: 'Numbering off' }); + li100.createEl('span', { text: ': If \'off\' appears, the document will not be numbered.' }); + new obsidian.Setting(containerEl) + .setName('Skip top heading level') + .setDesc('If selected, numbering will not be applied to the top heading level.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.skipTopLevel) + .setTooltip('Skip top heading level') + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.skipTopLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('First heading level') + .setDesc('First heading level to number.') + .addSlider(slider => slider + .setLimits(1, 6, 1) + .setValue(this.plugin.settings.firstLevel) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.firstLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Start numbering at') + .setDesc('Start numbering the first heading level from this value.') + .addText(text => text + .setValue(this.plugin.settings.startAt) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.startAt = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Maximum heading level') + .setDesc('Maximum heading level to number.') + .addSlider(slider => slider + .setLimits(1, 6, 1) + .setValue(this.plugin.settings.maxLevel) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.maxLevel = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Style for level 1 headings') + .setDesc('Defines the numbering style for level one headings. Valid values are 1 (for numbers) or A (for capital letters) or I (for Roman numerals).') + .addText(text => text + .setValue(this.plugin.settings.styleLevel1) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.styleLevel1 = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Style for lower level headings (below level 1)') + .setDesc('Defines the numbering style for headings below level one. Valid values are 1 (for numbers) or A (for capital letters) or I (for Roman numerals).') + .addText(text => text + .setValue(this.plugin.settings.styleLevelOther) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.styleLevelOther = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Automatic numbering') + .setDesc('Turns on automatic numbering of documents.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.auto) + .setTooltip('Turn on automatic numbering') + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.auto = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Separator style') + .setDesc('Defines the separator style between the heading number and the heading text. Valid values are : (colon) or . (dot) or - (dash) or — (emdash) or ) (a right parenthesis). You can also leave it blank for no separator, or have a space before the separator.') + .addText(text => text + .setValue(this.plugin.settings.separator) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.separator = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Table of Contents Anchor') + .setDesc('Anchor which labels the header where a table of contents should be inserted. The anchor should be added at the end of a header. For example, ^toc.') + .addText(text => text + .setValue(this.plugin.settings.contents) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.contents = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Skip Headings Anchor') + .setDesc('Anchor which labels the headers that should not be numbered. The anchor should be added at the end of a header. For example, ^skipped.') + .addText(text => text + .setValue(this.plugin.settings.skipHeadings) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.skipHeadings = value; + yield this.plugin.saveSettings(); + }))); + } +} +class NumberHeadingsPlugin extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + // eslint-disable-next-line no-console + console.info('Loading Number Headings Plugin, version ' + this.manifest.version); + yield this.loadSettings(); + this.addCommand({ + id: 'number-headings-with-options', + name: 'Number all headings in document (and show options)', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + if (settings.off) + return false; + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + showNumberingDoneMessage(this.app, settings); + } + return false; + } + }); + this.addCommand({ + id: 'number-headings', + name: 'Number all headings in document', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + if (settings.off) + return false; + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + // NOTE: The line below is intentionally commented out, since this command is the same as + // the above command, except for this line + // showNumberingDoneMessage(this.app, settings, viewInfo) + } + return false; + } + }); + this.addCommand({ + id: 'remove-number-headings', + name: 'Remove numbering from all headings in document', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + removeHeadingNumbering(viewInfo); + return true; + } + }); + this.addCommand({ + id: 'save-settings-to-front-matter', + name: 'Save settings to front matter', + checkCallback: (checking) => { + if (checking) + return isViewActive(this.app); + const viewInfo = getViewInfo(this.app); + const file = this.app.workspace.getActiveFile(); + if (viewInfo && file) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + saveSettingsToFrontMatter(this.app.fileManager, file, settings); + } + return false; + } + }); + this.addSettingTab(new NumberHeadingsPluginSettingTab(this.app, this)); + this.registerInterval(window.setInterval(() => { + const viewInfo = getViewInfo(this.app); + if (viewInfo) { + const settings = getFrontMatterSettingsOrAlternative(viewInfo.data, this.settings); + if (settings.off) + return; + if (settings.auto) { + updateHeadingNumbering(viewInfo, settings); + setTimeout(() => { + // HACK: This must happen after a timeout so that there is time for the editor transaction to complete + const postNumberingViewInfo = getViewInfo(this.app); + updateTableOfContents(postNumberingViewInfo, settings); + }, 3000); + // eslint-disable-next-line no-console + console.log('Number Headings Plugin: Automatically numbered document'); + } + } + }, 10 * 1000)); + }); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); + } +} + +module.exports = NumberHeadingsPlugin; + + +/* nosourcemap */ \ No newline at end of file diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/manifest.json b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/manifest.json new file mode 100644 index 0000000..c7cd633 --- /dev/null +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "number-headings-obsidian", + "name": "Number Headings", + "version": "1.16.0", + "minAppVersion": "1.4.0", + "description": "Automatically number or re-number headings in an Obsidian document", + "author": "Kevin Albrecht (onlyafly@gmail.com)", + "authorUrl": "https://www.kevinalbrecht.com", + "isDesktopOnly": false +} \ No newline at end of file diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/styles.css b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/styles.css new file mode 100644 index 0000000..12a666b --- /dev/null +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/plugins/number-headings-obsidian/styles.css @@ -0,0 +1,8 @@ +div.number-headings-button-container > button { + font-weight: normal; +} + +div.number-headings-question { + font-weight: bold; + margin-bottom: 10px; +} \ No newline at end of file diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/workspace.json b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/workspace.json index 5090775..8317b79 100644 --- a/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/workspace.json +++ b/BovedasObsidian/Tesis De Grado Berlatzky/.obsidian/workspace.json @@ -51,16 +51,16 @@ "state": { "type": "markdown", "state": { - "file": "Notas de tesis de doctorado de Ing. Edgardo Jose Marchi.md", + "file": "Comienzo de las simulaciones.md", "mode": "source", "source": false }, "icon": "lucide-file", - "title": "Notas de tesis de doctorado de Ing. Edgardo Jose Marchi" + "title": "Comienzo de las simulaciones" } } ], - "currentTab": 2 + "currentTab": 3 } ], "direction": "vertical" @@ -210,16 +210,17 @@ "command-palette:Open command palette": false } }, - "active": "7116c73b124d7abe", + "active": "095d1d4b691267bf", "lastOpenFiles": [ + "Duda que surge de escribir la primera simulación.md", + "Comienzo de las simulaciones.md", + "Notas de paper Sensors-14-02595.md", + "Notas de tesis de doctorado de Ing. Edgardo Jose Marchi.md", "Gestión de proyectos/Informe de Proyecto de gestión de proyectos.md", "Gestión de proyectos/Consulta de la introducción de Informe de proyecto.md", "Titulo de la nueva nota.md", "Materiales/TesisDeReferencia/VanderPlas_2018_ApJS_236_16.pdf", "Materiales/TesisDeReferencia/tesis.pdf", - "Comienzo de las simulaciones.md", - "Duda que surge de escribir la primera simulación.md", - "Notas de tesis de doctorado de Ing. Edgardo Jose Marchi.md", "Materiales/TesisDeReferencia/lomb.pdf", "Esquemas/Esquema del proyecto.canvas", "Esquemas/Esquemas Secundarios/Procesmiento de la señal.canvas", @@ -229,7 +230,6 @@ "Materiales/Adicionales/Merrill Ivan Skolnik - Introduction to Radar Systems-Mcgraw-Hill College (1980).pdf", "Imagenes/Screenshot_2.png", "Imagenes/Esquema_Radar_Impulsivo.png", - "Notas de paper Sensors-14-02595.md", "Materiales/Adicionales/[Stoica_P.,_Moses_R.L.]_Spectral_analysis_of_signa(b-ok.xyz).pdf", "Materiales/Adicionales/EstimacionEspectral.pdf", "Notas del paper Understanding the Lomb-Scargle Periodogram.md", diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/Comienzo de las simulaciones.md b/BovedasObsidian/Tesis De Grado Berlatzky/Comienzo de las simulaciones.md index 2428906..fc61821 100644 --- a/BovedasObsidian/Tesis De Grado Berlatzky/Comienzo de las simulaciones.md +++ b/BovedasObsidian/Tesis De Grado Berlatzky/Comienzo de las simulaciones.md @@ -1,6 +1,6 @@ -## Capítulo 1: Las primeras simulaciones +## 1. Capítulo 1: Las primeras simulaciones -### Simulación De la señal de distancia, la señal de radar y los dos muestreos +### 1.1. Simulación De la señal de distancia, la señal de radar y los dos muestreos Discutiendo con Cecilia, ella me dio una idea de por donde empezar a realizar las simulaciones del problema. A diferencia de como se hacían las simulaciones en probabilidad u otras materias, acá no conviene, o es imposible simular el problema es su totalidad a la vez. No se puede modelar todo y uno no puede ponerse a resolver el problema de una. Hay que empezar de apoco y por las partes que se puede. Lo que Cecilia recomendó es comenzar por comenzar a simular las señales que se esperarían medir, que según la tesis de [[Notas de paper Sensors-14-02595]]. La ecuación para la distancia que tiene en la tesis es de la forma: @@ -23,7 +23,7 @@ Para la generación de la señal de radar se utiliza la señal descrita en [[Not Estas simulaciones fueron un éxito ya que se logro observar la señal de distancia como el desfasaje de la señal de radar. Esto se puede ver en [[Screenshot_2.png]]. -### Demodulación de la señal radar recibida +### 1.2. Demodulación de la señal radar recibida Para poder enviar la señal de radar por el aire hay que modularla. Lo que hace el radar para poder transmitir por este medio es modular el pulso enviado mediante DBL-PS (Doble Banda Lateral - Portadora Suprimida). Lo que se modelo hasta este momento es la señal electromagnética que se vería en la antena receptora. Ahora hay que pasar a aplicarle el procesamiento que le hace el radar para obtener información de la señal recibida. @@ -36,7 +36,36 @@ Que es lo que esta haciendo el receptor para obtener la información? El recepto Y finalmente, luego de sumar las dos señales se le aplica un filtro pasa bajos para elimina las dos bandas de frecuencia formadas en los laterales y quedarse con un espectro de frecuencia similar al inicial. Esta señal que obtenemos no es la señal inicial reflejada por el ambiente porque tiene multiplicando un termino extra que depende del tiempo de vuelo de la onda y contiene la información deseada. Este termino es el resultado de la suma de las dos multiplicaciones. Para ver el desarrollo ver la tesis de Edgardo. [[Notas de tesis de doctorado de Ing. Edgardo Jose Marchi]] (Podría copiarme el desarrollo a las notas que tengo.) -### + +## 2. Capítulo 2: Simulaciones del análisis de espectro de la señal distancia. + +### 2.1. Análisis MUSIC de nuestra señal $d(t)$ + +Lo primero que descubrí al comenzar ha hacer los primeros análisis espectrales de la señal es que estaba mal simulada la señal distancia. Estaban mal establecidos los limites de la frecuencia cardiaca. Corregí esto y ya esta bien simulada. + +Para hacerle un análisis con el método MUSIC a nuestra señal le pregunte a Chat GPT que librerías podía utilizar y me menciono la librería "spectrum", así que me la descargue y comencé a trabajar con ella. Ante una primera interacción con estas funciones se puede ver que el análisis espectral MUSIC tiene algunos parámetros que modifican el resultado, los cuales son: el largo de la ventana, la frecuencia de muestreo, la cantidad de componentes de la matriz de MUSIC, la cantidad de componentes asignadas al ruido, la cercanía de las dos componentes de frecuencia. Además de estos, hay uno que quiero comprender el impacto que es el NFFT. + +Durante mis pruebas iniciales con esta función descubrimos con Cecilia que tenia las dos frecuencias de nuestra señal muy juntas y las separé para facilitar el análisis inicial. Luego tengo que juntarlas un poco para ver los limites del método. + +#### 2.1.1. Descripción de la función "pmusic" + +La función "spectrum.pmusic" realiza el análisis espectral la función que le pases y te devuelve el análisis espectral de la función. Si se quiere acceder a la documentación de esta función se puede utilizar el vinculo siguiente: https://pyspectrum.readthedocs.io/en/latest/ref_psd_other.html#spectrum.eigenfre.pmusic . + +DUDA: En la documentación establece que la función pmusic utiliza métodos ARMA para obtener la PSD. Pero esto no es así en la teoría. En la teoría el método MUSIC parte de asumir a tus funciones como composiciones de senoidales y esto no desenlaza en un método ARMA. + +Descripción de los parámetros de importancia y/o que entiendo: +- IP: Es la cantidad máxima de autovalores que computa la función. Es decir, que es la suma máxima de cantidad de componentes de señal y de componentes de ruido. +- NSIG: Es la cantidad autovalores que se le asignan al ruido dentro de entre todos los autovalores. Este valor tiene que ser menor a IP. +- NFFT: Este parámetro se utiliza cuando se quiere hacer un padeo con ceros por si se tiene pocas muestras. Es para completar con ceros y mejorar el ventaneo. + +Yo lo veo como indicar que "Componentes de señal" $= IP - NSIG$. + +#### 2.1.2. Variación de la frecuencia de muestreo + +Durante mis pruebas iniciales del método MUSIC, más específicamente durante la recreación del ejemplo de la documentación, note que yo estaba utilizando una frecuencia de muestreo muy alta en comparación con el ejemplo y al bajar la frecuencia de muestreo me lograba identificar las dos frecuencias que componen la señal cuando antes no lo hacía. + +Por esto, el primer experimento va a ser explorar para que frecuencias de muestreo de la señal detecta o no detecta las dos frecuencias. Esto lo vamos a hacer inicialmente para un valor de IP y NSIG. Creo que voy a empezar con un valor de $IP = 5 y $NSIG = 1$, ya que para estos parámetros se hayo alguna frecuencia de muestreo que se detectan los dos picos. +Luego se va a probar de bajar y subir la cantidad de componentes para ver como reacciona el resultado. diff --git a/BovedasObsidian/Tesis De Grado Berlatzky/Notas de paper Sensors-14-02595.md b/BovedasObsidian/Tesis De Grado Berlatzky/Notas de paper Sensors-14-02595.md index fc492a5..6c0884b 100644 --- a/BovedasObsidian/Tesis De Grado Berlatzky/Notas de paper Sensors-14-02595.md +++ b/BovedasObsidian/Tesis De Grado Berlatzky/Notas de paper Sensors-14-02595.md @@ -1,4 +1,4 @@ -## Capítulo 0: Abstract +## 1 Capítulo 0: Abstract En este capitulo hace un resumen de todos los temas que se tratan. Los temas que se tratan son: - El procesamiento para la estimación de la apnea del sueño. @@ -10,7 +10,7 @@ En este capitulo hace un resumen de todos los temas que se tratan. Los temas que - La forma de detectar el ritmo respiratorio. - (Habla algo de la dependencia de la amplitud de la señal recibida con la orientación del individuo con respecto a las antenas por lo que se colocan varias antenas) -## Capítulo 1: Introducción +## 2 Capítulo 1: Introducción En los primeros párrafos habla de los que es la apnea obstructiva del sueño (OSA) y sus consecuencias. Además, habla de que lo que generalmente se utiliza es para detectarla es un Polisomnografía (PSG) que mide una variedad de parámetros biológicos pero es muy costoso. En definitiva esta explicando las motivaciones de la investigación. Luego habla de otros métodos de medición como el Pletismografía Inductiva Respiratoria (RIP) en el que se le ajustan unas bandas elásticas al paciente para medir el volumen de aire que respira el paciente. @@ -28,12 +28,12 @@ Indica que la principal contribución del paper es que se utiliza una promedio m (FALTA TERMINAR ESTA SECCION) -## Capítulo 2: UWB Radar Setup +## 3 Capítulo 2: UWB Radar Setup En el comienzo del capítulo describe el setup físico utilizado para realizar las experiencias. Lo mas llamativo de esto es la utilización de una antena emisora y 2 antenas receptoras posicionadas a 90 grados una de la otra. Para tomar datos de las dos antenas se lo hace de forma alternada. Una medición es de una y la siguiente es de la otra. Además de la configuración física describe la configuración de las frecuencias seleccionadas para el radar. -## Capítulo 3: Teoría del problema -### Detección de la señal de respiración +## 4 Capítulo 3: Teoría del problema +### 4.1 Detección de la señal de respiración Cuando el pulso electromagnético impacta en el paciente, parte de este rebota debido a la alta reflectividad del paciente. Algo que hay que tener en cuenta es que el coeficiente de reflexión del paciente tiene que ver con la orientación de este. diff --git a/Simulaciones/PrimerasSimulaciones.ipynb b/Simulaciones/PrimerasSimulaciones.ipynb index a6a59e1..23ed07f 100644 --- a/Simulaciones/PrimerasSimulaciones.ipynb +++ b/Simulaciones/PrimerasSimulaciones.ipynb @@ -459,7 +459,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -541,7 +541,8 @@ "\tResultado_Desfasaje = Evaluacion_Señal_Lenta(ValoresLinea, Distancia_Paciente, Amplitud_Respitatoria, Frecuencia_Respiratoria, \n", " Fase_Respiracion, Amplitud_Cardiaca, Frecuencia_Cardiaca, Fase_Cardiaca)\n", "\n", - "\treturn ValoresLinea, Resultado_Desfasaje\n", + "\tLista_Elementos = list([Frecuencia_Respiratoria[0], Frecuencia_Cardiaca[0], Amplitud_Respitatoria[0], Amplitud_Cardiaca[0]])\n", + "\treturn ValoresLinea, Resultado_Desfasaje, Lista_Elementos\n", "\n", "\n", "Tiempo_Inicio = 0\n", @@ -549,27 +550,27 @@ "Periodo_Muestreo_Lenta = 0.01\n", "Seed = 42\n", "\n", - "ValoresLinea, Resultado_Desfasaje= Generacion_Muestras(Tiempo_Inicio, Tiempo_Fin, Periodo_Muestreo_Lenta, Seed)\n", + "ValoresLinea, Resultado_Desfasaje, Lista_Parametros= Generacion_Muestras(Tiempo_Inicio, Tiempo_Fin, Periodo_Muestreo_Lenta, Seed)\n", "\n", "plt.figure()\n", "plt.plot(ValoresLinea,Resultado_Desfasaje)\n", "plt.grid()\n", "\n", - "print(\"Frecuencia respiratoria:\",Frecuencia_Respiratoria[0])\n", - "print(\"Frecuencia cardiaca:\", Frecuencia_Cardiaca[0])\n", + "print(\"Frecuencia respiratoria:\",Lista_Parametros[0])\n", + "print(\"Frecuencia cardiaca:\", Lista_Parametros[1])\n", "\n", - "print(\"Amplitud respiratoria\", Amplitud_Respitatoria[0])\n", - "print(\"Amplitud cardiaca\", Amplitud_Cardiaca[0])\n" + "print(\"Amplitud respiratoria\", Lista_Parametros[2])\n", + "print(\"Amplitud cardiaca\", Lista_Parametros[3])\n" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -579,7 +580,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -589,7 +590,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -599,7 +600,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -615,8 +616,8 @@ "Periodo_Muestreo_Lenta = 0.01\n", "\n", "\n", - "Cantidad_Componentes = 10\n", - "Componentes_Ruido = 2\n", + "Cantidad_Componentes = 5\n", + "Componentes_Ruido = 1\n", "Estimacion_PMUSIC = spectrum.pmusic(Resultado_Desfasaje-np.mean(Resultado_Desfasaje), IP=Cantidad_Componentes, NSIG=Cantidad_Componentes-Componentes_Ruido, sampling=1/Periodo_Muestreo_Lenta)\n", "Fig_MMUSIC = Estimacion_PMUSIC.plot()\n", "\n",