Xwork's Blog

Ahora veremos un ejemplo, para eso modificaremos un poco el programa en C# que prueba la conjetura de Collatz. para empezar veamos el código.

using System;
using System.Windows.Forms;
using System.Numerics;
using System.Threading;

namespace ConjeturaDeCollatz
{
	public partial class FrmMain : Form
	{
		private delegate void UpdateListDelegate(string Value);

		private void UpdateList(string Value)
		{
			if (LBResults.InvokeRequired)
			{
				LBResults.Invoke(new UpdateListDelegate(UpdateList), Value);
			}
			else
			{
				LBResults.Items.Add(Value);
			}
		}
		private void CalculateCollatz(string Number)
		{
			BigInteger MyNumber;
			BigInteger.TryParse(Number, out MyNumber);
			while (MyNumber > 1)
			{
				Thread.Sleep(1500);
				if (MyNumber.IsEven == false)
				{
					MyNumber = MyNumber * 3 + 1;
					UpdateList(MyNumber.ToString());
				}
				else
				{
					MyNumber = MyNumber / 2;
					UpdateList(MyNumber.ToString());
				}
			}
		}
		private void RunWork(string Number)
		{
			Thread DoWork = new Thread(new ThreadStart(() => CalculateCollatz(Number)));
			DoWork.Start();
		}
		private void RunWorkWithNoThread(string Number)
		{
			CalculateCollatz(Number);
		}
		public FrmMain()
		{
			InitializeComponent();
		}

		private void BtnStart_Click(object sender, EventArgs e)
		{
			LBResults.Items.Clear();
			RunWork(TxtNumberIn.Text);

		}

		private void BtnStart2_Click(object sender, EventArgs e)
		{
			RunWorkWithNoThread(TxtNumberIn.Text);
		}
	}
}

Para poder hacer las pruebas, modificamos un poco el código que ya teníamos y además, agregamos un botón para que la acción se ejecute pero no en un hilo separado, si hace clic en este botón, verás que la aplicacion parecerá que se bloquea e incluso si presiona muchas veces el botón de cerrar, windows te preguntará si quieres cerrar la aplicación porque esta no responde, pero no es el caso; el proceso sigue corriendo de manera "normal", pero debido a que se encuentra la ejecución dentro del bucle "while" no puede responder a las peticiones del usuario. Por lo que simplemente podemos esperar (el usuario más bien) a que todo acabe, de cualquier forma los resultados no son necesarios.

Caso dos "necesito esos datos".

Cuando los datos son necesarios, debemos de hallar una forma de informar al usuario cuando hay datos listos para usarse, para eso vamos a crear un hilo secundario, imaginemos que queremos escalar 1000 imágenes y a cada una arreglarle el color, por lo que se debe de hacer de una por una a la vez; pero solo parte del trabajo humano porque el proceso de escalar las imágenes se puede hacer poniendo todas en una cola y escalarlas y solo cuando se ha procesado la primera, abrirla para empezar a trabajar con ella y en el fondo el escalado del resto de las imágenes puede seguir ya que nos va a tomar varios minutos en ajustar  nuestra imagen a lo que necesitamos.

En alguno de los post que hemos hecho, hicimos un programa en android que se conectaba al bluetooth del Clock View (puedes ver el post), hacemos uso de dos tipos de thread, en la primera, simplemente notificábamos al usuario que se está realizando la conexión entre el dispositivo y Clock view y cuando esta se llevaba a cabo, un "thread" diferente se se ejecutaba y su función era manejar todos los datos que se transmitían desde/hacia el dispositivo y el bluetooth y mientas no se pida que la conexión se cierre (o se cierre la aplicación), este hilo seguirá corriendo en el fondo.

Y bien, por ahora es todo, el código de la conjetura de Collatz lo puedes modificar para probar el ejemplo de este post. En los siguiente post continuaremos con más programación.
Los leo luego

// Original de https://developer.android.com/reference/android/os/AsyncTask
 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
	 protected Long doInBackground(URL... urls) {
		 int count = urls.length;
		 long totalSize = 0;
		 for (int i = 0; i < count; i++) {
			 totalSize += Downloader.downloadFile(urls[i]);
			 publishProgress((int) ((i / (float) count) * 100));
			 // Escape early if cancel() is called
			 if (isCancelled()) break;
		 }
		 return totalSize;
	 }

	 protected void onProgressUpdate(Integer... progress) {
		 setProgressPercent(progress[0]);
	 }

	 protected void onPostExecute(Long result) {
		 showDialog("Downloaded " + result + " bytes");
	 }
 }
 

Esta clase se construye de la siguiente forma: DownloadFilesTask extends AsyncTask<URL, Integer, Long>,  suponiendo que se llame a ejecutar con los siguientes parametros: "URL1", "URL2","URL3","URL4"..."URL10". El parámetro URL contendrá estos diez valores distintos entonces en "doInBackground(URL.. urls)" lo que se hace es primero asignar los parámetros a la variable "urls" y luego medir los elementos con "urls.length" y cada parámetro pasado al momento de iniciar la ejecución, estará en esta matriz. EL resultado de "doInBackground"  es del tipo "Long" que usaremos en "onPostExecute" para mostrar al usuario cuantos bytes se descargaron. Cada vez que se ejecute "publishProgress()" en "doInBackGround()", se ejecutará "onProgressUpdate()", en esta parte es donde debemos de cambiar cualquier indicador de progreso. finalmente en "onPostExecute()", mostraremos un dialogo con la información de cuantos bytes se descargaron.

En post anteriores ya hemos usado "AsyncTask"

Y bien, por ahora es todo, en el siguiente post añadiremos una barra de progreso y entenderemos mejor cómo y cuando debemos de hacer uso de "AsyncTask".

Cómo ya vimos cuales son las reglas de los números de Munchhausen en el primer post, ahora pasaremos directamente al código en java para poder usarlo. El código es el siguiente:

package com.mdev.munchhausen;

import android.app.Activity;
import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.ListView;
import android.widget.TextView;

import java.util.ArrayList;

public class MainActivity extends Activity {

	Button BtnDowork;
	TextView TXTMin, TxtMax;
	CheckBox CHKShowAll;
	ListView ShowResults;
	private ProgressDialog progress;

	private boolean IsMunchhausenNumber(String Number)
	{
		int Value = 0;
		int CurrentNumber = 0;
		char[] Digits = Number.toCharArray();
		for (int i = 0; i < Digits.length; i++)
		{
			CurrentNumber = Digits[i] - 48;
			Value += (int)Math.pow(CurrentNumber,CurrentNumber);
		}
		String CurrentVal = String.valueOf(Value);
		if (Number.compareTo(CurrentVal) == 0)
			return true;
		else
			return false;
	}

	private ArrayList TestNumbers(int BeginNumber, int EndNumber, int ShowAll)
	{
		ArrayList TempList = new ArrayList();
		for (int i = BeginNumber; i <= EndNumber; i++)
		{
			if (IsMunchhausenNumber(String.valueOf(i)))
				TempList.add( "La conjetura se cumple para el número " + i);
			else if (ShowAll == 1)
				TempList.add( "El número " + i + " no cumple la conjetura");;
		}
		return TempList;
	}
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		BtnDowork = (Button)findViewById(R.id.BtnDoWork);
		TXTMin = (TextView)findViewById(R.id.TXTInMin);
		TxtMax = (TextView)findViewById(R.id.TXTInMax);
		CHKShowAll = (CheckBox)findViewById(R.id.CHKShowAll);
		ShowResults = (ListView) findViewById(R.id.LVResults);
		BtnDowork.setOnClickListener(new View.OnClickListener() {
										 @Override
										 public void onClick(View v) {
											 Integer ShowAll = 0;
											 Integer Min = Integer.valueOf(TXTMin.getText().toString());
											 Integer Max = Integer.valueOf(TxtMax.getText().toString());
											 if (CHKShowAll.isChecked())
												 ShowAll = 1;
											 else
												 ShowAll = 0;
												new UpdateList().execute(Min,Max,ShowAll);
										 }
									 }

		);
	}

	private  class UpdateList extends AsyncTask<Integer,Void,ArrayList>
	{
		@Override
		protected void onPreExecute()
		{
			progress = ProgressDialog.show(MainActivity.this, "Espera...", "Espera...!!!");
		}
		@Override
		protected ArrayList doInBackground(Integer... Limits)
		{
			ArrayList Lista = new ArrayList();
			Lista = TestNumbers(Limits[0],Limits[1],Limits[2]);
			return Lista;
		}
		@Override
		protected void onPostExecute(ArrayList result)
		{
			super.onPostExecute(result);
			final ArrayAdapter adapter = new ArrayAdapter(MainActivity.this,android.R.layout.simple_list_item_1, result);
			ShowResults.setAdapter(adapter);
			progress.dismiss();
		}
	}
}

El código ha cambiado un poco, en el caso de la función "IsMunchhuasenNumber()", todo se mantiene igual, es decir; se prueba un número y si este cumple la conjetura, la funcion devuelve "true", en caso contrario se devuelve "false".

La función "TestNumbers", es la que sufrido varios cambios. Para empezar, los parámetros que está recibe, los primeros dos se mantienen del tipo "int", pero el tercer parámetro pasa a ser del tipo "boolean" al tipo "int", esto solo hace por practicidad, un poquito más adelante veremos el por qué. Otro de los cambios que sufre, es que ahora pasa a ser una función en vez de un procedimiento. El valor que regresa es un valor del tipo "ArrayList", que es la lista en la cual se van almacenado los valores de salida. Cada vez que se prueba la conjetura para un número, se regresa una cadena de texto similar a "el número n no/cumple la conjetura", en la versión de C#, directamente se usaba el delegado y la función "UpdateList()" para hacerlo pero en este y debido a cómo está estructurado, pensé que era mejor hacerlo así.

A diferencia de los muchos otros códigos que he dicho que voy a "optimizar" (y que no he hecho), este ahora si usa un "Thread" diferente para hacer los cálculos y que no se bloquee la interfaz principal, para eso hacemos uso de la Subclase "UpdateList" que hereda de la clase "AsyncTask" (no se si sea en valido decir "hereda" en java, pero creo que si o si no se entiende). En el post de la semana que viene, veremos cómo usar esta clase para poder brindar un poco de "Multithreading", pero por ahora, al crear la instancia, pasamos tres parámetros que son "<Integer, Void, ArrayList>". Para poder usar la clase "AsyncTask", debemos de sobrecargar algunos de los metodos que la componen, en este caso solo son tres (pero hay más) y son: "onPreExecute()", "doInBackground()" y "onPostExecute()". Respectivamente cada uno hace lo siguiente: Es lo que se ejecutará antes de empezar, la parte principal y que mas tiempo va a consumir y la parte donde se procesaran los resultados.

Con el código anterior podemos probar los números de Munchhausen en un dispositivo con android, en el siguiente post veremos cómo es que funciona la clase "AsyncTask" y cómo nos podra ayudar con tareas en segundo plano. El código cómo de costumbre lo pongo en mi dropbox para que lo descargues, recuerda que a partir de este post, solo ira el código del layout principal y el código java. El APK ya compilado lo puedes descargar de mi dropbox directamente o puedes visitar la seccion de descargas del blog.

Y bien, por ahora es todo, los leo luego.

El código en javascript para probar los números de Munchhausen es el siguiente:

<html>
	<head>
		<style type="text/css">
		.h1M
		{
			font-size: 16px;
		}
		.formVigenere{
			font: 95% Arial, Helvetica, sans-serif;
			max-width: 400px;
			margin: 10px auto;
			padding: 16px;
			background: #F9F9F9;
		}
		.textareaM
		{
			width: 100%;
			height: 150px;
			padding: 2px 5px;
			box-sizing: border-box;
			border: 2px solid #999;
			border-radius: 4px;
			resize: none;
			-webkit-transition-duration: 0.4s; /* Safari */
			transition-duration: 0.4s;
		}

		.textareaM:focus
		{
			width: 100%;
			height: 150px;
			padding: 2px 5px;
			box-sizing: border-box;
			border: 2px solid #00BB00;
			border-radius: 4px;
			resize: none;
		}

		.TextM
		{
			width: 100%;
			box-sizing: border-box;
			border: 2px solid #999;
			border-radius: 4px;
		}

		.ButtonM
		{
		width: 100%;
			background-color: #009900;
			border: none;
			color: white;
			padding: 15px 32px;
			text-align: center;
			text-decoration: none;
			display: inline-block;
			-webkit-transition-duration: 0.4s; /* Safari */
			transition-duration: 0.4s;
		}

		.ButtonM:hover
		{
		width: 100%;
			background-color: #4CAF50;
			border: none;
			color: white;
			padding: 15px 32px;
			text-align: center;
			text-decoration: none;
			display: inline-block;
		}
		</style>
		<script type="text/javascript">
		function NumberToDigits(Number){
			var Out = [];
			for(var i = 0; i < Number.length; i++){
				var CodeChar = Number.charCodeAt(i);
					Out.push(CodeChar - 48);
			}
			return Out;
		}

		function IsMunchhausen(Number){
			var Result = 0;
			var Digits = NumberToDigits(Number);
			for(var i = 0; i < Digits.length; i++){
				Result += Math.pow(Digits[i], Digits[i]);
			}
			if (Number == Result.toString()){
				return true;
			}
			else{
				return false;
			}
		}
		function TestNumbers(){
			document.getElementById('Result').value = "";
			BeginNumber = document.getElementById('MinNumber').value;
			EndNumber = document.getElementById('MaxNumber').value;
			SHowAll = document.getElementById('ShowAll').checked;
			for (var i = BeginNumber; i <= EndNumber; i++){
				if (IsMunchhausen(i.toString()))
					document.getElementById('Result').value += "La conjetura se cumple para el número " + i + "\n";
				else if (SHowAll)
					document.getElementById('Result').value += "El número " + i + " no cumple la conjetura\n";
			}
		}
		 </script>
	</head>
	<body>
	Utilidad para probar la conjetura de Munchhausen usando javascript.
	<form class="formVigenere">
		<span class="h1M">Numero de donde empezar:</span>
		<br />
		<input class="TextM" id="MinNumber" value = "1" type="text"></input><br />
		<span class="h1M">Numero hasta donde llegar</span><br /><br/>
		<input class="TextM" id="MaxNumber" value = "5000" type="text" /><br />
		<br />
		<input class="ButtonM" id="Calcula" onclick="TestNumbers()" type="button" value="Calcular" /><br />
		<br />
		<input type="checkbox" id = "ShowAll" value="Bike">Mostrar Todo<br><br>
		<span class="h1M">Resultado</span><br/>
		<textarea class="textareaM" id="Result" rows="5"></textarea><br/><br/>
	</form>
	</body>
<html>

El código anterior solo consta de tres funcione en esta ocasión en la función "NumberToDigits()" al convertir el número de entrada a los dígitos que lo forman, directamente hace la resta de 48 para poder usar el número directamente. Para poder recuperar los valores de cada control, hacemos uso de la función "document.getElementById".



Cómo de costumbre, el código lo dejo en mi dropbox para que lo pruebes, al ser el mismo "concepto" que la versión de C#, no requiere una explicación mayor. La semana que viene, veremos la versión para android.

Los leo luego.

El código en C# que sirve para probar la conjetura es el siguiente:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace Munchhausen
{
	public partial class FrmMain : Form
	{
		private bool IsBusy = false;
		private delegate void UpdateListDelegate(string Value);
		private void UpdateList(string Value)
		{
			if (LBResults.InvokeRequired)
				LBResults.Invoke(new UpdateListDelegate(UpdateList), Value);
			else
				LBResults.Items.Add(Value);
		}
		private bool IsMunchhausenNumber(string Number)
		{
			int Value = 0;
			int CurrentNumber = 0;
			char[] Digits = Number.ToCharArray();
			for (int i = 0; i < Digits.Length; i++)
			{
				CurrentNumber = Digits[i] - 48;
				Value += (int)Math.Pow(CurrentNumber,CurrentNumber);
			}
			if (Number == Value.ToString())
				return true;
			else
				return false;
		}
		private void TestNumbers(int BeginNumber, int EndNumber, bool SHowAll)
		{
			for (int i = BeginNumber; i <= EndNumber; i++)
			{
				if (IsMunchhausenNumber(i.ToString()))
					UpdateList("La conjetura se cumple para el número " + i);
				if (SHowAll)
					UpdateList("El número " + i + " no cumple la conjetura");
			}
			IsBusy = false;
		}
		private void RunWork(int Minimum, int Maximun, bool ShowAll = false)
		{
			Thread DoWork = new Thread(new ThreadStart(() => TestNumbers(Minimum, Maximun,ShowAll)));
			IsBusy = true;
			DoWork.Start();
		}
		public FrmMain()
		{
			InitializeComponent();
		}

		private void BtnStart_Click(object sender, EventArgs e)
		{
			LBResults.Items.Clear();
			if (!IsBusy)
				RunWork(int.Parse(TxtMinNumber.Text), int.Parse(TxtMaxNumber.Text),CHKShowTrue.Checked);
			else
				MessageBox.Show("Hay una operación en proceso, espera","MDev",MessageBoxButtons.OK,MessageBoxIcon.Exclamation);
		}

		private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
		{
			if (IsBusy == true)
			{
				MessageBox.Show("No se puede salir ahora","MDev", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
				e.Cancel = true;
			}
		}
	}
}

El código anterior consta de cuatro funciones, pero solo la función "IsMunchhausenNumber()" es la que hace el trabajo, el resto solo son para poder usar la aplicación y que esta no se bloquee cuando se realice el proceso.

La función "IsMunchhausenNumber" recibe un parámetro del tipo "string" que será la cadena de texto que representa el número que se va a probar; decidí tomar directamente el parámetro cómo un "string" debido a que cuando recuperamos el número de la caja de texto, este sera de ese tipo, entonces convertirlo y luego hacer una conversión más para poder separarlo en los dígitos, significa doble trabajo.

Dentro de la función, convertimos el parámetro ingresado en un "array" del tipo "char", cada elemento representara un dígito del número ingresado. Luego para poder hacer los cálculos con cada dígito, a cada valor del tipo "char" le restamos 48 para obtener su valor real. Hay que recordar que el tipo "char" es esencialmente igual al tipo "byte" por lo que podemos restar (aunque habría que hacer la conversión implícita pero meh). La razón por la que se resta 48, es porque el número cero, esta en el lugar 48, el uno es 49 y así sucesivamente hasta el número nueve. Si intentamos convertir el valor del tipo "char" "0" a uno del tipo "int", este regresará 48, por lo que hacer la resta directamente resulta más fácil.

Después con los numero ya separados se hace la suma siguiendo las reglas de la conjetura y se compara el valor de la variable usada para hacer la suma con el número ingresado cómo parámetro; si estos son iguales entonces la función devuelve un valor del tipo "bool" "true", en caso contrario devuelve "false".

Para probar los número, se hace uso de la función "TestNumbers". Esta función recibe tres parámetros, el primero del tipo "int" que servirá cómo limite mínimo para empezar a probar los números. El segundo parámetro también del tipo "int" sirve para marcar el limite máximo hasta cual se van a probar los números, finalmente el tercer parámetro del tipo "bool", servirá par filtrar los resultados; solo cuando este sea "true", todos los resultados sin importar que cumplan la conjetura, se agregan a la lista de salida, en caso contrario, solo los que la cumplen son agregados.

Y bien, por ahora es todo en futuros post veremos que hacen el resto de las funciones (que de seguro habrás notado que aparecen en varios de los programas del blog) y probablemente al igual que algunos otros de los programas, crearemos versiones para android en java y web en javascript. Cómo de costumbre, puedes descargar el código fuente de mi dropbox para que lo pruebes.

Los leo luego

Preliminar: SISMO Magnitud 5.9 Loc 9 km al NOROESTE de H HUAJUAPAN DE LEON, OAX 19/07/18 08:31:56 Lat 17.87 Lon -97.83 Pf 55 km pic.twitter.com/XHR6JQUEg3

— Sismologico Nacional (@SismologicoMX) 19 de julio de 2018

El ciclo for sirve para hacer N veces determinada tarea, en pascal la forma más básica de si uso es la siguiente:

{ ... }
{ ... }
	for {Desde} to {hasta} do
	begin
		{ haz algo }
	end;
{...}
{...}

Para hacer uso del ciclo, debemos de hacer uso de la palabra reservada "for" seguida del número desde cual se va empezar a contar, se debe de usar una variable que es la que usaremos a manera de contador. Seguido viene la palabra reservada "to" y despues viene lo que será el "tope" del ciclo, una vez indicado esto viene la palabra reservada "do" y dependiendo de cuanto código vamos a usar, podemos hacer uso de "begin" (para inidicar el inicio), todo el código contenido entre éste y su respectivo "end;", será lo que se ejecutará hasta que el contador llegue al limite indicado.

Ahora imaginemos que queremos hacer un programa que cuente del 1 al 100 y que además escriba "este mensaje se ha escrito N veces" en la consola. tomando en cuenta lo anterior, podemos hacer código cómo el siguiente:

Program Ciclofor;
uses crt, sysutils;
var
Contador : integer;
begin
	for Contador := 1 to 100 do
	begin
		writeln(concat('Este mensaje se ha escrito ', IntToStr(Contador) ,' veces usando for'));
	end;
	readln();
end.

Repeat until.

El bucle Repeat until, es muy similar al bucle while, es decir el ciclo se repetirá hasta que cierta condicion se cumpla.

Para hacerlo, primero debemos de hacer uso de la palabra reservada "repeat", luego escribiremos todo el código que se va a ejecutar y finalmente, pondremos la palabra reservada "until" y la condición que se debe de cumplir.

En la forma más simple, el bucle repeat tendrá la siguiente forma:

{ ... }
{ ... }
	repeat
		{ haz algo }
		{ haz algo }
		{ haz algo }		
		{ haz algo }
	until ({condicion});
{...}
{...}

Para tener una mejor idea de cómo se usa, vamos a hacer el mismo programa que usamos cómo ejemplo en el ciclo "for" solo que ahora lo adaptaremos a "repeat".

Program RepeatUntil;
uses crt, sysutils;
var
Contador : integer;
begin
	Contador := 100;
	repeat
		writeln(concat('Este mensaje se ha escrito ', IntToStr(Contador) ,' veces usando until'));
		Contador := Contador + 1;
	until (Contador > 100);
	readln();
end.

Algo importante que hay que resaltar, es que "repeat" a diferencia de "while", ejecutará al menos una vez el código dentro del bloque, esto debido a que la expresion se evalua hasta el final, cosa contraria a "while". Si quieres probar esto, puedes asignarle el valor de 100 a la variable "Contador" justo antes de "Repeat", la condicion ya se cumple, porque por obvio que parezca, 100 es mayor que 99.

Y bien, por ahora es todo, en post futuros veremos más aprendizaje de pascal (incluso la primer imagen te puede dar una idea de lo que viene). Puedes copiar los códigos anteriores para probarlos.

Los leo luego.

Con el interprete ya instalado veamos el código.

-----------De la documentación disponible en http://www.id3.org para la versión 2---------------
--[[
Para la version 2.2
	Header for 'Attached picture', ID: "APIC">
	Text encoding   $xx
	MIME type       <text string> $00
	Picture type    $xx
	Description     <text string according to encoding> $00 (00)
	Picture data    <binary data>
Para la version 2.0
	Attached picture   "PIC"
	Frame size         $xx xx xx
	Text encoding      $xx
	Image format       $xx xx xx
	Picture type       $xx
	Description        <textstring> $00 (00)
	Picture data       <binary data>
]]
function WriteImage(NombreDeLaCancion,NombreDeLaImagen)
--Abrimos el archivo en modo de lectura binario
	local Rdata = io.open(NombreDeLaCancion,"rb")
--Ponemos el puntero al inicio del archivo
	Rdata:seek("set")
--Ahora leemos los primeros 1024b del archivo, si no encontramos aquí la etiqueta "APIC" o "PIC" asumimos que el archivo no tiene imagen embebida
	local Sdata = Rdata:read(1024)
--En esta variable Guardaremos la ubicación del La etiqueta "APIC"
	local GotIt = string.find(Sdata,"APIC")
--Si GotIt es nil en este punto, buscamos la etiqueta PIC
	if GotIt == nil then
		GotIt = string.find(Sdata,"PIC")
	end
--
--Si la variable GotIt tiene cualquier valor diferente de nil; procedemos a buscar el tipo de imagen que este embebida.
	if GotIt ~= nil then
		local GotPNG =string.find(Sdata,string.char(137)..string.char(80)..string.char(78)..string.char(71))
	--Obtenemos la versión
		local GetVer = string.find(Sdata,"APIC")
--La comprobación es simple ya llegados a este punto; si uno es falso el otro debe de ser verdadero.		
--Regresamos el puntero a la posición en donde se encontró la etiqueta APIC y leemos la longitud de la etiqueta
		local b1,b2,b3,b4
		local TagSize	
		if GetVer ~= nil then
			Rdata:seek("set",GotIt+3)
			b1=string.byte(Rdata:read(1))*256*256*256
			b2=string.byte(Rdata:read(1))*256*256
			b3=string.byte(Rdata:read(1))*256
			b4=string.byte(Rdata:read(1))
			TagSize = b1+b2+b3+b4+10
		else
			Rdata:seek("set",GotIt+2)
			b1=string.byte(Rdata:read(1))*256*256
			b2=string.byte(Rdata:read(1))*256
			b3=string.byte(Rdata:read(1))
			TagSize = b1+b2+b3+5
		end
--Si los datos dicen que la imagen es JPG
		if GotPNG  == nil then
			local JPicInit = string.find(Sdata,string.char(255)..string.char(216)..string.char(255))
			Rdata:seek("set",JPicInit-1)
			IMGData = Rdata:read(TagSize-(JPicInit-GotIt))
			local MPImg = io.open(NombreDeLaImagen..".jpg","wb")
			MPImg:write(IMGData)
			MPImg:flush()
			MPImg:close()
			MPImg=nil
		else
			local PPicInit = string.find(Sdata,string.char(137).."PNG")
			local TagDMP
			if GetVer then
				TagDMP=8
			else
				TagDMP=6
			end
			Rdata:seek("set",PPicInit-1)
			local IMGData = Rdata:read(TagSize-(PPicInit-GotIt))
			MPImg = io.open(NombreDeLaImagen..".png","wb")
			MPImg:write(IMGData)
			MPImg:flush()
			MPImg:close()
			MPImg=nil
		end
	end
	Rdata:close()
	Rdata = nil
end

print("Inserta la ubicacion de un mp3")
local FILE = io.read();
print("Inserta un nombre de archivo")
local SavePlace = io.read();
WriteImage(FILE, SavePlace);

Primero que nada, LUA dispone de funciones de lectura y escritura bastante similares a los de C. Para usar un lector, debemos de iniciarlo pasando dos parámetros, uno de ellos es el archivo que queremos leer (o nuestra canción) y el segundo parámetro es el modo en cual se abrirá; en este caso, usamos "rb" que indicará que leeremos el archivo de forma "binaria".

Al igual que en C, disponemos de una función que sirve para desplazarnos en el archivo que tenemos abierto. Antes de continuar, hay que aclarar algo; LUA no es un lenguaje orientado a objetos pero tiene una sintaxis que ayuda a simularlo y para el código anterior es lo mismo "Rdata:seek("set");" que "Rdata = io.seek("set");" y lo mismo para todos los procedimiento provenientes de cualquier "clase" así que una vez que se inicializa una variable del tipo "io", podemos usar el nombre que le dimos seguido de dos puntos para acceder a los sub-métodos. Entonces, usando "seek" sin ningún parámetro adicional a "set", le indicamos que queremos mover el puntero al inicio del archivo (byte cero)

Cuando ya iniciamos todo, leemos los primeros 1024 bytes del archivo y al igual que en C#, vamos a buscar cualquiera de las etiquetas que se usan para indicar una imagen; es decir: "APIC" o "PIC". Algo que probablemente olvide decir en el primer post sobre imágenes en los MP3's es la importancia de buscar primero "APIC" a algunos les resultará obvio cual es la razón pero a otros no. La razón es simple si buscamos PIC (que corresponde a la versión 2), el resultado de la búsqueda sera verdadero si existe "APIC" porque esta contiene toda la cadena de caracteres que buscamos, en cambio si buscamos "APIC" primero, si no se encuentra, eso no significa que necesariamente no exista "PIC".

Para realizar la búsqueda de la etiqueta, una vez que leímos todos los bytes en los cuales podría estar, creamos un flag llamado "GotIt" del tipo "boolean" y a esta le asignamos el resultado de la función "string.find()" usando cómo parámetros "Sdata" que es una copia de "Rdata" (los 1024 bytes leídos) y es en donde buscará la cadena de texto que le pasamos en el segundo parámetro.

Repetimos lo anterior 4 veces, la primera es para buscar "APIC", la segunda para buscar "PIC" luego si la variable "GotIt" resulta "true" en cualquiera de las dos funciones, hacemos una nueva búsqueda pero ahora en lugar de las etiquetas de imagen, buscamos el tipo de imagen; ya sea PNG o JPG, pero para hacerlo, hacemos uso de de los caracteres que sirven de "encabezado" para los archivos PNG, cómo ya estamos dentro de la condición en la cual si se encontró una etiqueta de imagen, solo hacemos una comprobación y si no encontramos al "encabezado" del archivo PNG entonces la imagen es JPG

Para calcular el tamaño de las imágenes, hay que recordar que seguido de la etiqueta, los cuatro bytes siguientes  para la versión tres y los tres bytes siguiente en la versión dos, indican cual es el tamaño de total de la etiqueta, para poder saber cual es el valor, bastará con multiplicar cada byte por potencias de 256, empezando de izquierda a derecha por 256^3 para la versión 3 y 256^2 para la versión dos.

Finalmente  guardamos la imagen haciendo uso de un escritor de archivos que se usa igual al de C, es decir creamos el archivo e indicamos cual es el modo en el cual se trabajara, cuando usamos "wb" indicamos que abriremos un archivo pra escribir de forma binaria, si el archivo no existe, se creara uno nuevo.

Para poder usar la función, en ZeroBrane presionaremos F6 y en la parte inferior, el programa no preguntará por la ubicación de una canción seguido de la ubicación que usaremos para guardar la imagen, para este ultimo es importante solo indicar la ruta y el nombre del archivo sin extensión, dentro del programa al determinar si la imagen es jpg o png automáticamente agrega la extensión adecuada.

Si observas bien, el archivo de imagen solo tiene la ruta y el nombre, pero no la extensión.

Y bien por ahora es todo, el código lo puedes copiar y pegar para probarlo.

Los leo luego.