[VB] Type mag niet groter dan 64K? Help!

[DarksandII]

Hallo, Ik zit met een rot probleem in Visual Basic. Ik heb de code erbij geplaatst.

Ik wil graag een ASE File (Export 3d studio) in een type plaatsen zodat ik hem direct met Put #1, recnum, data naar bestand kan schrijven.

Ik heb nu een aantal types gemaakt, en deze worden allemaal weer in andere types opgenomen, totdat er 1 type overblijft.

Nu komt het probleem, types mogen dus niet groter zijn dan 64K
Dus bij de definitie van het type Mesh krijg ik de foutmelding:

Fixed or static data can't be larger than 64K.

Ik heb op de microsoft site gekeken, en deze zeggen dat dit "by design" is

Mijn vraag is, weten jullie een andere oplossing om deze data alsnog netjes in
één gegevensstructuur te krijgen. Anders moet ik alle Sub categorien los op schijf opslaan. Ik heb liever één Bestand per 3d object.

code:

'for mesh
Type vertex_list
    vertexnumber                        As Long
    x                                   As Double
    y                                   As Double
    z                                   As Double
End Type
'for mesh
Type Face_List
    Facenumber                          As Long
    a                                   As Long
    B                                   As Long
    C                                   As Long
    AB                                  As Byte
    BC                                  As Byte
    CA                                  As Byte
    Smoothing                           As Byte
    MTLID                               As Byte
End Type

'for facenormals
Type VertexNormals
    Number                              As Long
    a                                   As Single
    B                                   As Single
    C                                   As Single
End Type

'for Mesh
Type FaceNormals
    Number                              As Long
    a                                   As Single
    B                                   As Single
    C                                   As Single
    VertexNormals(3)                    As VertexNormals
End Type

'for GeomObject
Type node
    Nodename                            As String
    INHERIT_POS_A                       As Integer
    INHERIT_POS_B                       As Integer
    INHERIT_POS_C                       As Integer
    INHERIT_ROT_A                       As Integer
    INHERIT_ROT_B                       As Integer
    INHERIT_ROT_C                       As Integer
    INHERIT_SCL_A                       As Integer
    INHERIT_SCL_B                       As Integer
    INHERIT_SCL_C                       As Integer
    TM_ROW0_X                           As Single
    TM_ROW0_Y                           As Single
    TM_ROW0_Z                           As Single
    TM_ROW1_X                           As Single
    TM_ROW1_Y                           As Single
    TM_ROW1_Z                           As Single
    TM_ROW2_X                           As Single
    TM_ROW2_Y                           As Single
    TM_ROW2_Z                           As Single
    TM_ROW3_X                           As Single
    TM_ROW3_Y                           As Single
    TM_ROW3_Z                           As Single
    TM_POS_X                            As Single
    TM_POS_Y                            As Single
    TM_POS_Z                            As Single
    TM_ROTAXIS_X                        As Single
    TM_ROTAXIS_Y                        As Single
    TM_ROTAXIS_Z                        As Single
    TM_ROTANGLE                         As Single
    TM_SCALE_X                          As Single
    TM_SCALE_Y                          As Single
    TM_SCALE_Z                          As Single
    TM_SCALEAXIS_X                      As Single
    TM_SCALEAXIS_Y                      As Single
    TM_SCALEAXIS_Z                      As Single
    TM_SCALEAXISANG                     As Single
End Type

Type Mesh
    Time_value                          As Integer
    numvertex                           As Long
    numfaces                            As Long
    vertex_list(1000)                   As vertex_list  'numvertex
    Face_List(1000)                     As Face_List    'numfaces
    Mesh_NumTVertex                     As Integer
    Mesh_NumCVertex                     As Integer
    FaceNormals(1000)                   As FaceNormals  'numfaces
End Type

Type Material
    materialnumber As Integer
End Type

Type GeomObject
    ObjectName                          As String
    Material                            As Material
    node                                As node
    Mesh                                As Mesh
End Type

[DaRealRenzel]

Als jij weet hoe lang je data is en die schrijf je sequentieel weg naar 1 bestand, dan kun je achteraf dit toch ook weer zomaar inlezen ? Bedoel, je eerste type is 1 long en 3 doubles, dat zijn dus 1x 32 + 3x 16 bits. Je tweede type is 4 longs en 5 bytes, dus 4x16 + 5x8 dus als je eerst 80 bits en daarna 72 bytes leest van disk en die in je types stopt, dan klopt het toch weer ?

Ik bedoel dus een beetje op de manier hoe DBAse3 (jaja, oud) bestanden zijn opgebouwd. De eerste 4 bytes beschrijven hoelang de header is. (bijv. 64 bytes). De Header beschrijft hoe een data record er uit ziet (byv. eerst een byte, dan een string van max. 40 chars, dan een long etc). als je dus eerst de eerste 4 bytes inleest weet je hoeveel bytes je moet lezen om de header te lezen (zeg dus 64 bytes). Dan lees je dus data vanaf byte 68, en die is altijd conform de beschrijving in de header.

[ Voor 40% gewijzigd door DaRealRenzel op 10-04-2004 00:48 ]

[DarksandII]

DaRealRenzel schreef op 10 april 2004 @ 00:44:
Als jij weet hoe lang je data is en die schrijf je sequentieel weg naar 1 bestand, dan kun je achteraf dit toch ook weer zomaar inlezen ? Bedoel, je eerste type is 1 long en 3 doubles, dat zijn dus 1x 32 + 3x 16 bits. Je tweede type is 4 longs en 5 bytes, dus 4x16 + 5x8 dus als je eerst 80 bits en daarna 72 bytes leest van disk en die in je types stopt, dan klopt het toch weer ?

Je hebt gelijk, enkel dan wordt het vreselijk onoverzichtelijk, maar ik ben bang dat er geen andere optie is.

Deze types zijn eigenlijk niet enkel voor IO, maar zorgen ook voor een gestructureerde afhandeling in de rest van het programma.

Weet hier ook iemand of dit in bijvoorbeeld Visual C beter af te handelen is.

[DarksandII]

Ik bedoel dus een beetje op de manier hoe DBAse3 (jaja, oud) bestanden zijn opgebouwd. De eerste 4 bytes beschrijven hoelang de header is. (bijv. 64 bytes). De Header beschrijft hoe een data record er uit ziet (byv. eerst een byte, dan een string van max. 40 chars, dan een long etc). als je dus eerst de eerste 4 bytes inleest weet je hoeveel bytes je moet lezen om de header te lezen (zeg dus 64 bytes). Dan lees je dus data vanaf byte 68, en die is altijd conform de beschrijving in de header.

Daarmee kan je wel weer een mooie structuur krijgen, en dan de Aray's gewoon wat kleiner houden, met andere woorden, ik ben hier wel weer een paar dagen zoet mee

[Verwijderd]

Ik heb op de microsoft site gekeken, en deze zeggen dat dit "by design" is

Van origine kan één data segment maar 64 KB zijn, is een beperking van de processor.

[DarksandII]

Verwijderd schreef op 10 april 2004 @ 02:14:
[...]

Van origine kan één data segment maar 64 KB zijn, is een beperking van de processor.

Dat is inderdaad zo, maar je zou zeggen dat VB hier toch wel een oplossing voor heeft bedacht. blijkt dus niet het geval. Het zou toch mooi zijn als hij het over meerder registers kan uitsmeren.

[RobIII]

DarksandII schreef op 10 april 2004 @ 02:37:
[...]


Dat is inderdaad zo, maar je zou zeggen dat VB hier toch wel een oplossing voor heeft bedacht. blijkt dus niet het geval. Het zou toch mooi zijn als hij het over meerder registers kan uitsmeren.

Je zou classes kunnen gebruiken i.p.v. (user defined) types. Dat zou moeten werken en is relatief weinig werk om aan te passen.

DaRealRenzel schreef op 10 april 2004 @ 00:44:
Als jij weet hoe lang je data is en die schrijf je sequentieel weg naar 1 bestand, dan kun je achteraf dit toch ook weer zomaar inlezen ? Bedoel, je eerste type is 1 long en 3 doubles, dat zijn dus 1x 32 + 3x 16 bits.

Sinds wanneer is een double 16 bits?

code:

    Dim d As Double
    Dim s As Single
    Dim b As Byte
    Dim i As Integer
    Dim l As Long
    
    Debug.Print "Type", "Bytes", "Bits"
    Debug.Print String(35, "=")
    Debug.Print TypeName(d), Len(d), Len(d) * 8
    Debug.Print TypeName(s), Len(s), Len(s) * 8
    Debug.Print TypeName(b), Len(b), Len(b) * 8
    Debug.Print TypeName(i), Len(i), Len(i) * 8
    Debug.Print TypeName(l), Len(l), Len(l) * 8

Output:

code:

Type          Bytes         Bits
===================================
Double         8             64 
Single         4             32 
Byte           1             8 
Integer        2             16 
Long           4             32

DaRealRenzel schreef op 10 april 2004 @ 00:44:
Je tweede type is 4 longs en 5 bytes, dus 4x16 + 5x8 dus als je eerst 80 bits en daarna 72 bytes leest van disk en die in je types stopt, dan klopt het toch weer ?

Je schept nogal wat verwarring door bits en bytes door elkaar te gebruiken

[ Voor 79% gewijzigd door RobIII op 10-04-2004 02:49 ]

[DarksandII]

RobIII schreef op 10 april 2004 @ 02:38:
[...]

Je zou classes kunnen gebruiken i.p.v. (user defined) types. Dat zou moeten werken en is relatief weinig werk om aan te passen.

Ik moet eerlijk zeggen dat ik nog niets met classes ooit heb gedaan, ik zal wel ff wat rond zoeken, want als dat echt een oplossing biedt, dan ben ik gelukkig. Als je nog wat meer info hebt dan mag je dat altijd plaatsen natuurlijk.

[RobIII]

DarksandII schreef op 10 april 2004 @ 02:54:
[...]
Ik moet eerlijk zeggen dat ik nog niets met classes ooit heb gedaan, ik zal wel ff wat rond zoeken, want als dat echt een oplossing biedt, dan ben ik gelukkig. Als je nog wat meer info hebt dan mag je dat altijd plaatsen natuurlijk.

Tja... Classes zijn eigenlijk de "object" tegenhanger van het UDT. Alleen kunnen ze veel meer.

Ik vergelijk ze meestal met een textbox. Je geeft een class properties (.text, .maxlength e.d.) maar ook bijvoorbeeld methods (.setfocus, .refresh) geven. Alleen hoef je een class niet te zien op een form zoals een textbox, maar als abstract object. Een mooie class is bijvoorbeeld de class "User" met de properties:
• .Name
• .LastName
• .RegisteredDate
enz, en met de methods
• .ResetPassword(strNewPWD as string)
• .Delete()
• .Move(strGroupName as string)

Nogmaals, dit is maar een uit de mouw geschud voorbeeld.

Een class bevat meestal "intern" stukjes code, dus is in essentie en soort "black-box". Je stopt er iets in en er komt iets uit (hoe de class aan de uitkomst komt is dan verder dus niet belangrijk).

Moeilijk, moeilijk... Hoe leg je classes snel en simpel uit?.... tja...

Ik zal je UDT eens in een class gooien...


Start een leeg project. Voeg 4 classes toe en noem de classes face_normal, face_normals, vertex_list en vertex_normal.

Paste in de class face_normal de volgende code:

Visual Basic:

Option Explicit

Public Number As Long
Public a As Single
Public B As Single
Public C As Single
Public VertexNormals As New vertex_normal

Paste in de class face_normals de volgende code:

Visual Basic:

Option Explicit

Public face_normal1 As New face_normal
Public face_normal2 As New face_normal
Public face_normal3 As New face_normal

Paste in de class vertex_list de volgende code:

Visual Basic:

Option Explicit

Public vertexnumber As Long
Public x As Double
Public y As Double
Public z As Double

En tot slot in de class vertex_normal de code:

Visual Basic:

Option Explicit

Public Number As Long
Public a As Single
Public B As Single
Public C As Single

Ga nu naar je Form1 en paste daarin de code:

Visual Basic:

Option Explicit

Private Sub Form_Load()
    Dim myVertexList As vertex_list
    Dim myFaceNormals As face_normals
    
    Set myVertexList = New vertex_list
    With myVertexList
        .vertexnumber = 1
        .x = 199
        .y = 156
        .z = 38
    End With
    
    Set myFaceNormals = New face_normals
    With myFaceNormals
        .face_normal1.a = 1
        .face_normal1.B = 2
        .face_normal3.a = 312312
        .face_normal3.VertexNormal.Number = 2
    End With
End Sub

Je hebt nu een hele simpele mapping van UDT naar classes gemaakt.
Maar classes kunnen meer. Zo hebben we nu gewoon een aantal public vars gedimt die de class beschikbaar stelt als een property. Maar je kan aan een class ook dit toevoegen:

Voeg deze code toe aan je class face_normal:

Visual Basic:

Private m_strName

Public Property Let FaceName(strName As String)
    strName = Trim(strName) 'Trim spaties
    If Len(strName) > 50 Then   'Check of naam niet te lang is
        MsgBox "The name '" & strName & "' is too long! (50 chars max)"
    Else    'Naam is ok, opslaan
        m_strName = strName
    End If
End Property

Public Property Get FaceName() As String
    FaceName = m_strName
End Property

Je object myFaceNormals heeft nu een .FaceName property. Geef je het myFaceNormals object een te lange naam (langer dan 50 chars) via het property dan wordt deze naam niet doorgevoerd en wordt er een msgbox gegeven.

Dit is zomaar een voorbeeldje hoor!

Een Method kun je als volgt toevoegen:

Open je class vertex_list en paste:

code:

Public Sub Clear()
    vertexnumber = 0
    x = 0
    y = 0
    z = 0
End Sub

Public Function GetSum()
    GetSum = x + y + z
End Function

Public Function GetSumEx(bIncludeX As Boolean, _
                    bIncludeY As Boolean, bIncludeZ As Boolean)
    GetSumEx = IIf(bIncludeX, x, 0) + IIf(bIncludeY, y, 0) + IIf(bIncludeZ, z, 0)
End Function

Je kunt nu b.v. myVertexList.Clear aanroepen om alle properties te clearen, of myVertexList.GetSum om de som van x+y+z terug te krijgen. myVertexList.GetSumEx neemt 3 parameters, en telt, afhankelijk van de parameters, (x)+(y)+(z) op.

Je kunt ook events raise-en in classes. Dan wordt het helemaal leuk.

Dit was een korte inleiding in classes. Ik probeer zeer zeker niet compleet te zijn, noch correct, maar dit moet je een aardige schop in de juiste richting geven.

Meer over classes vind je natuurlijk op MSDN en Google

Please, vertel me dat deze post geen verloren moeite was?

offtopic:
Ik kan hier ook nog een heel verhaal gaan houden over early vs. late-binding, over class_initialise en class_terminate, objecten op Nothing zetten, collecties, public/private/friend properties, interfaces, polymorphisme en dan kan ik nog wel uren doordraven over vanalles en nogwat... Maar ik denk dat ik maar eens in bedje kruip

[ Voor 28% gewijzigd door RobIII op 10-04-2004 03:42 ]

[DarksandII]

Please, vertel me dat deze post geen verloren moeite was?

Alhoewel het mij allemaal een beetje suist in de oren (en ik ook niet echt veel slaap heb gehad ) ziet dit er echt zeer interesant uit. Ik zal mij hier vanavond proberen in te verdiepen (mot eerst meehelpen verhuizen en vanavond nog een feestje, ik hoop dat ik het volhoud) maar dit is wel zo interessant, hier moet ik meer van weten.

Ik ben zelf meer een QB programeur, maar daar kan ik niet zoveel meer mee (geen direct x bijvoorbeeld) En Visual C was mij toch iets te stijl. Ik zou graag meer van dit soort dingen willen weten... Als je MSN Messenger gebruikt, dan zou ik het prijs stellen als je [e-mail] toevoegd, zodat we nog eens Ideeen uit kunnen wisselen.

Voor dit alvast hartelijk dank. Want het was me wel een partijtje werk om dit al bedenken.

[BestTested!]

Ik ben zelf meer een QB programeur, maar daar kan ik niet zoveel meer mee (geen direct x bijvoorbeeld) En Visual C was mij toch iets te stijl. Ik zou graag meer van dit soort dingen willen weten...

Ik begrijp precies wat je bedoelt. IK ben ook begonnen met QB, en heb later de overstap gemaakt naar VB. Classes en OOP was dus een vaag gebied voor mij. Nu ben ik een tijd geleden ook met Java begonnen, en daar ging een wereld voor mij open .
Na een goed boek te hebben doorgespit (heeft me dik half jaar gekost) heb ik nog steeds niet alle voordelen van OOP/Classes door. Ik vind dat RobIII hierboven in een klein stukje tekst prima heeft uitgelegd wat Classes precies zijn. Complimenten . Als newbie op dit gebied zou ik zeggen, geef het een gooi. Als je het eenmaal doorhebt, wil je niet anders meer!

offtopic:
Ben big-fan nadat ik een prachtig neuraal netwerk heb opgezet om handgeschreven cijfers te herkennen. Zou met UDT denk ik nooit gelukt zijn

[Verwijderd]

File IO moet je in blokken doen. File openen, 1 blok van 32kB inlezen, data eruit pluizen en het volgende blok inlezen, etc. Je moet rekening houden met de filelengte i.v.m. het laatste blok! Van deze werkwijze zijn wel voorbeelden te vinden. Je kan werken met vaste recordlengte of CrLf als EndOfRecord gebruiken. Bij binaire inhoud is dit laatste niet mogelijk! Of je moet alles wegschrijven als leesbare tekens. Van je file IO maak je een utility class en voor elk type record een aparte class. Op hoger niveau kan je dan polymorfisme toepassen voor de record-verwerk methode.

[DarksandII]

Verwijderd schreef op 10 april 2004 @ 11:07:
File IO moet je in blokken doen. File openen, 1 blok van 32kB inlezen, data eruit pluizen en het volgende blok inlezen, etc. Je moet rekening houden met de filelengte i.v.m. het laatste blok! Van deze werkwijze zijn wel voorbeelden te vinden. Je kan werken met vaste recordlengte of CrLf als EndOfRecord gebruiken. Bij binaire inhoud is dit laatste niet mogelijk! Of je moet alles wegschrijven als leesbare tekens. Van je file IO maak je een utility class en voor elk type record een aparte class. Op hoger niveau kan je dan polymorfisme toepassen voor de record-verwerk methode.

Auw net terug van verhuizen....maar dat terzijde.

Ik denk als je naar performance gaat kijken, dat het inderdaad verstandig is, afgeronde blocken te lezen, maar waarom zeg jij 32KB, 64K kan toch net zo goed, alhoewel dat dan ook het maximum is nu .

Maar we gaan bezig met Classes, maar niet meer vandaag, val bijna om van de slaap, en straks nog een feestje.
Bedankt voor jullie hulp en blijf meer over classes posten.

[RobIII]

DarksandII schreef op 10 april 2004 @ 18:13:
[...]


Auw net terug van verhuizen....maar dat terzijde.

Ik denk als je naar performance gaat kijken, dat het inderdaad verstandig is, afgeronde blocken te lezen, maar waarom zeg jij 32KB, 64K kan toch net zo goed, alhoewel dat dan ook het maximum is nu .

Maar we gaan bezig met Classes, maar niet meer vandaag, val bijna om van de slaap, en straks nog een feestje.
Bedankt voor jullie hulp en blijf meer over classes posten.

Je kunt inderdaad blokken lezen (en ook nog stukken groter dan 64k hoor). Die code heb ik al meer dan 1.000 keer gepost hier

Zie daarvoor onder andere deze draad: [rml][ vb] Zoeken naar keyword in bestand[/rml]

Je kan, als je file niet erg groot is, zelfs het hele bestand in 1 klap inlezen...

Maar hoe dan ook, je hebt het dan nog steeds niet in een UDT of class, dus het nut heeft om hierover te discussieren

[ Voor 7% gewijzigd door RobIII op 10-04-2004 18:18 ]